@jskit-ai/users-core 0.1.48 → 0.1.50

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/users-core",
-  version: "0.1.48",
+  version: "0.1.50",
   kind: "runtime",
   description: "Users/account runtime plus HTTP routes for account features.",
   dependsOn: [
@@ -48,7 +48,7 @@ export default Object.freeze({
         },
         {
           subpath: "./shared",
-          summary: "Exports shared users settings and tenancy utilities."
+          summary: "Exports shared users settings resources and defaults."
         },
         {
           subpath: "./client",
@@ -128,11 +128,11 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/auth-core": "0.1.37",
-        "@jskit-ai/database-runtime": "0.1.38",
-        "@jskit-ai/http-runtime": "0.1.37",
-        "@jskit-ai/kernel": "0.1.38",
-        "@jskit-ai/uploads-runtime": "0.1.16",
+        "@jskit-ai/auth-core": "0.1.39",
+        "@jskit-ai/database-runtime": "0.1.40",
+        "@jskit-ai/http-runtime": "0.1.39",
+        "@jskit-ai/kernel": "0.1.40",
+        "@jskit-ai/uploads-runtime": "0.1.18",
         "@fastify/type-provider-typebox": "^6.1.0",
         typebox: "^1.0.81"
       },

package/package.json

@@ -1,33 +1,23 @@
 {
   "name": "@jskit-ai/users-core",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "type": "module",
   "scripts": {
     "test": "node --test"
   },
   "exports": {
-    "./server/UsersWorkspacesServiceProvider": "./src/server/UsersWorkspacesServiceProvider.js",
-    "./server/support/workspaceRouteInput": "./src/server/support/workspaceRouteInput.js",
-    "./server/support/resolveWorkspace": "./src/server/support/resolveWorkspace.js",
-    "./server/validators/routeParamsValidator": "./src/server/common/validators/routeParamsValidator.js",
+    "./server/profileSyncLifecycleContributorRegistry": "./src/server/profileSyncLifecycleContributorRegistry.js",
     "./shared/settings": "./src/shared/settings.js",
-    "./shared/tenancyProfile": "./src/shared/tenancyProfile.js",
-    "./shared/support/usersVisibility": "./src/shared/support/usersVisibility.js",
-    "./shared/support/workspacePathModel": "./src/shared/support/workspacePathModel.js",
-    "./shared/support/usersApiPaths": "./src/shared/support/usersApiPaths.js",
-    "./shared/resources/workspaceResource": "./src/shared/resources/workspaceResource.js",
-    "./shared/resources/workspaceSettingsResource": "./src/shared/resources/workspaceSettingsResource.js",
-    "./shared/resources/workspaceSettingsFields": "./src/shared/resources/workspaceSettingsFields.js",
     "./shared/resources/userProfileResource": "./src/shared/resources/userProfileResource.js",
     "./shared/resources/userSettingsFields": "./src/shared/resources/userSettingsFields.js",
     "./shared/resources/userSettingsResource": "./src/shared/resources/userSettingsResource.js"
   },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.37",
-    "@jskit-ai/database-runtime": "0.1.38",
-    "@jskit-ai/http-runtime": "0.1.37",
-    "@jskit-ai/kernel": "0.1.38",
-    "@jskit-ai/uploads-runtime": "0.1.16",
+    "@jskit-ai/auth-core": "0.1.39",
+    "@jskit-ai/database-runtime": "0.1.40",
+    "@jskit-ai/http-runtime": "0.1.39",
+    "@jskit-ai/kernel": "0.1.40",
+    "@jskit-ai/uploads-runtime": "0.1.18",
     "@fastify/type-provider-typebox": "^6.1.0",
     "typebox": "^1.0.81"
   }

package/src/server/common/services/authProfileSyncService.js

@@ -54,7 +54,17 @@ function requireSynchronizedProfile(profile) {
   throw new Error("Profile synchronization failed.");
 }
 
-function createService({ usersRepository, workspaceProvisioningService = null, userSettingsRepository = null } = {}) {
+function normalizeLifecycleContributors(entries = []) {
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+
+  return entries.filter(
+    (entry) => entry && typeof entry === "object" && typeof entry.afterIdentityProfileSynced === "function"
+  );
+}
+
+function createService({ usersRepository, lifecycleContributors = [], userSettingsRepository = null } = {}) {
   if (!usersRepository || typeof usersRepository.findByIdentity !== "function") {
     throw new Error("authProfileSyncService requires usersRepository.findByIdentity().");
   }
@@ -68,6 +78,8 @@ function createService({ usersRepository, workspaceProvisioningService = null, u
     throw new Error("authProfileSyncService requires userSettingsRepository.ensureForUserId().");
   }
 
+  const normalizedLifecycleContributors = normalizeLifecycleContributors(lifecycleContributors);
+
   async function findByIdentity(identityLike, options = {}) {
     const normalized = buildNormalizedIdentityKey(identityLike);
     return usersRepository.findByIdentity(
@@ -99,21 +111,30 @@ function createService({ usersRepository, workspaceProvisioningService = null, u
     const runSync = async (trx = null) => {
       const operationOptions = trx ? { ...options, trx } : options;
       const existing = await findByIdentity(normalized, operationOptions);
+      let created = false;
       if (!profileNeedsUpdate(existing, normalized)) {
         const synchronizedProfile = requireSynchronizedProfile(existing);
         await userSettingsRepository.ensureForUserId(synchronizedProfile.id, operationOptions);
+        for (const contributor of normalizedLifecycleContributors) {
+          await contributor.afterIdentityProfileSynced({
+            profile: synchronizedProfile,
+            created,
+            options: operationOptions
+          });
+        }
         return synchronizedProfile;
       }
 
       const upserted = await upsertByIdentity(normalized, operationOptions);
       const synchronizedProfile = requireSynchronizedProfile(upserted);
       await userSettingsRepository.ensureForUserId(synchronizedProfile.id, operationOptions);
-      if (
-        !existing &&
-        workspaceProvisioningService &&
-        typeof workspaceProvisioningService.provisionWorkspaceForNewUser === "function"
-      ) {
-        await workspaceProvisioningService.provisionWorkspaceForNewUser(synchronizedProfile, operationOptions);
+      created = !existing;
+      for (const contributor of normalizedLifecycleContributors) {
+        await contributor.afterIdentityProfileSynced({
+          profile: synchronizedProfile,
+          created,
+          options: operationOptions
+        });
       }
 
       return synchronizedProfile;

package/src/server/common/support/realtimeServiceEvents.js

@@ -5,12 +5,6 @@ function resolveActorScopedEntityId({ options } = {}) {
   return normalizeRecordId(options?.context?.actor?.id, { fallback: "" });
 }
 
-function resolveWorkspaceSlugPayload({ args } = {}) {
-  return {
-    workspaceSlug: String(args?.[0]?.slug || "").trim()
-  };
-}
-
 const ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS = deepFreeze([
   {
     type: "entity.changed",
@@ -36,56 +30,4 @@ const ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS = deepFreeze([
   }
 ]);
 
-function createWorkspaceEntityAndBootstrapEvents({
-  workspaceEntity,
-  workspaceOperation,
-  workspaceRealtimeEvent,
-  workspaceEntityId = ({ args }) => args?.[0]?.id,
-  bootstrapEntityId = ({ args }) => args?.[0]?.id,
-  bootstrapAudience = "event_scope"
-} = {}) {
-  const normalizedWorkspaceEntity = String(workspaceEntity || "").trim();
-  const normalizedWorkspaceOperation = String(workspaceOperation || "")
-    .trim()
-    .toLowerCase();
-  const normalizedWorkspaceRealtimeEvent = String(workspaceRealtimeEvent || "").trim();
-  if (!normalizedWorkspaceEntity || !normalizedWorkspaceOperation || !normalizedWorkspaceRealtimeEvent) {
-    throw new Error(
-      "createWorkspaceEntityAndBootstrapEvents requires workspaceEntity, workspaceOperation, and workspaceRealtimeEvent."
-    );
-  }
-  if (typeof workspaceEntityId !== "function") {
-    throw new Error("createWorkspaceEntityAndBootstrapEvents requires workspaceEntityId to be a function.");
-  }
-  if (typeof bootstrapEntityId !== "function") {
-    throw new Error("createWorkspaceEntityAndBootstrapEvents requires bootstrapEntityId to be a function.");
-  }
-
-  return deepFreeze([
-    {
-      type: "entity.changed",
-      source: "workspace",
-      entity: normalizedWorkspaceEntity,
-      operation: normalizedWorkspaceOperation,
-      entityId: (payload = {}) => normalizeRecordId(workspaceEntityId(payload), { fallback: "" }),
-      realtime: {
-        event: normalizedWorkspaceRealtimeEvent,
-        payload: resolveWorkspaceSlugPayload,
-        audience: "event_scope"
-      }
-    },
-    {
-      type: "entity.changed",
-      source: "users",
-      entity: "bootstrap",
-      operation: "updated",
-      entityId: (payload = {}) => normalizeRecordId(bootstrapEntityId(payload), { fallback: "" }),
-      realtime: {
-        event: "users.bootstrap.changed",
-        audience: bootstrapAudience
-      }
-    }
-  ]);
-}
-
-export { ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS, createWorkspaceEntityAndBootstrapEvents };
+export { ACCOUNT_SETTINGS_AND_BOOTSTRAP_EVENTS };

package/src/server/profileSyncLifecycleContributorRegistry.js

@@ -0,0 +1,56 @@
+import { registerTaggedSingleton, resolveTaggedEntries } from "@jskit-ai/kernel/server/registries";
+
+const PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG = "jskit.users.profileSync.lifecycleContributors";
+
+function normalizeProfileSyncLifecycleContributor(entry) {
+  if (typeof entry === "function") {
+    return Object.freeze({
+      contributorId: String(entry.name || "anonymous"),
+      order: 0,
+      afterIdentityProfileSynced: entry
+    });
+  }
+
+  if (!entry || typeof entry !== "object" || typeof entry.afterIdentityProfileSynced !== "function") {
+    return null;
+  }
+
+  const contributorId = String(entry.contributorId || "anonymous");
+  const order = Number.isFinite(entry.order) ? Number(entry.order) : 0;
+
+  return Object.freeze({
+    ...entry,
+    contributorId,
+    order,
+    afterIdentityProfileSynced: entry.afterIdentityProfileSynced
+  });
+}
+
+function registerProfileSyncLifecycleContributor(app, token, factory) {
+  registerTaggedSingleton(app, token, factory, PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG, {
+    context: "registerProfileSyncLifecycleContributor"
+  });
+}
+
+function resolveProfileSyncLifecycleContributors(scope) {
+  return resolveTaggedEntries(scope, PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG)
+    .map((entry, index) => ({
+      contributor: normalizeProfileSyncLifecycleContributor(entry),
+      index
+    }))
+    .filter((entry) => Boolean(entry.contributor))
+    .sort((left, right) => {
+      if (left.contributor.order !== right.contributor.order) {
+        return left.contributor.order - right.contributor.order;
+      }
+
+      return left.index - right.index;
+    })
+    .map((entry) => entry.contributor);
+}
+
+export {
+  PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG,
+  registerProfileSyncLifecycleContributor,
+  resolveProfileSyncLifecycleContributors
+};

package/src/server/registerUsersBootstrap.js

@@ -12,7 +12,6 @@ function registerUsersBootstrap(app) {
       usersRepository: scope.make("usersRepository"),
       userSettingsRepository: scope.make("userSettingsRepository"),
       appConfig: resolveAppConfig(scope),
-      tenancyProfile: scope.make("users.tenancy.profile"),
       authService: scope.make("authService")
     });
   });

package/src/server/registerUsersCore.js

@@ -1,30 +1,18 @@
-import { resolveAppConfig } from "@jskit-ai/kernel/server/support";
-import { resolveTenancyProfile } from "../shared/tenancyProfile.js";
 import { createService as createAuthProfileSyncService } from "./common/services/authProfileSyncService.js";
-import { registerUsersCoreActionSurfaceSources } from "./support/workspaceActionSurfaces.js";
+import { resolveProfileSyncLifecycleContributors } from "./profileSyncLifecycleContributorRegistry.js";
 
 function registerUsersCore(app) {
   if (!app || typeof app.singleton !== "function") {
     throw new Error("registerUsersCore requires application singleton().");
   }
 
-  registerUsersCoreActionSurfaceSources(app);
-
   app.singleton("users.profile.sync.service", (scope) => {
     return createAuthProfileSyncService({
       usersRepository: scope.make("usersRepository"),
       userSettingsRepository: scope.make("userSettingsRepository"),
-      workspaceProvisioningService:
-        typeof scope.has === "function" && scope.has("users.workspace.service")
-          ? scope.make("users.workspace.service")
-          : null
+      lifecycleContributors: resolveProfileSyncLifecycleContributors(scope)
     });
   });
-
-  app.singleton("users.tenancy.profile", (scope) => {
-    const appConfig = resolveAppConfig(scope);
-    return resolveTenancyProfile(appConfig);
-  });
 }
 
 export { registerUsersCore };

package/src/server/usersBootstrapContributor.js

@@ -2,15 +2,6 @@ import { AppError } from "@jskit-ai/kernel/server/runtime";
 import { requireServiceMethod } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
 import { normalizeLowerText, normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
 import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
-import {
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  WORKSPACE_SLUG_POLICY_NONE,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
-  WORKSPACE_SLUG_POLICY_USER_SELECTED,
-  resolveTenancyProfile
-} from "../shared/tenancyProfile.js";
 import { accountAvatarFormatter } from "./common/formatters/accountAvatarFormatter.js";
 import { authenticatedUserValidator } from "./common/validators/authenticatedUserValidator.js";
 import { userSettingsFields } from "../shared/resources/userSettingsFields.js";
@@ -56,10 +47,8 @@ function normalizeBoolean(value, fallback) {
   return fallback;
 }
 
-function resolveAppState(appConfig = {}, { workspaceInvitationsEnabled = false } = {}) {
+function resolveAppState(appConfig = {}) {
   const features = {
-    workspaceSwitching: normalizeBoolean(appConfig.workspaceSwitching, false),
-    workspaceInvites: workspaceInvitationsEnabled === true,
     assistantEnabled: normalizeBoolean(appConfig.assistantEnabled, false),
     assistantRequiredPermission: normalizeText(appConfig.assistantRequiredPermission),
     socialEnabled: normalizeBoolean(appConfig.socialEnabled, false),
@@ -71,54 +60,14 @@ function resolveAppState(appConfig = {}, { workspaceInvitationsEnabled = false }
   };
 }
 
-function normalizeSlugPolicy(value = "") {
-  const normalizedValue = normalizeLowerText(value);
-  if (
-    normalizedValue === WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME ||
-    normalizedValue === WORKSPACE_SLUG_POLICY_USER_SELECTED
-  ) {
-    return normalizedValue;
-  }
-  return WORKSPACE_SLUG_POLICY_NONE;
-}
-
-function isSupportedTenancyMode(value = "") {
-  return value === TENANCY_MODE_NONE || value === TENANCY_MODE_PERSONAL || value === TENANCY_MODE_WORKSPACES;
-}
-
-function resolveBootstrapTenancyProfile(tenancyProfile = null, appConfig = {}) {
-  const fallback = resolveTenancyProfile(appConfig);
-  const source = tenancyProfile && typeof tenancyProfile === "object" ? tenancyProfile : fallback;
-  const mode = isSupportedTenancyMode(source?.mode) ? source.mode : fallback.mode;
-  const workspace = source?.workspace && typeof source.workspace === "object" ? source.workspace : fallback.workspace;
-
-  return Object.freeze({
-    mode,
-    workspace: Object.freeze({
-      enabled: workspace.enabled === true,
-      autoProvision: workspace.autoProvision === true,
-      allowSelfCreate: workspace.allowSelfCreate === true,
-      slugPolicy: normalizeSlugPolicy(workspace.slugPolicy)
-    })
-  });
-}
-
-function createAnonymousBootstrapPayload({ appState, tenancyProfile, surfaceAccess = {} }) {
+function createAnonymousBootstrapPayload({ appState, surfaceAccess = {} }) {
   return {
     session: {
       authenticated: false
     },
     profile: null,
-    tenancy: tenancyProfile,
     app: appState,
-    workspaces: [],
-    pendingInvites: [],
-    activeWorkspace: null,
-    membership: null,
-    requestedWorkspace: null,
-    permissions: [],
     surfaceAccess: normalizeObject(surfaceAccess),
-    workspaceSettings: null,
     userSettings: null,
     requestMeta: {
       hasRequest: false
@@ -151,12 +100,10 @@ function createUsersBootstrapContributor({
   usersRepository,
   userSettingsRepository,
   appConfig = {},
-  tenancyProfile = null,
   authService
 } = {}) {
   const contributorId = "users.bootstrap";
   const appState = resolveAppState(appConfig);
-  const resolvedTenancyProfile = resolveBootstrapTenancyProfile(tenancyProfile, appConfig);
 
   requireServiceMethod(usersRepository, "findById", contributorId, {
     serviceLabel: "usersRepository"
@@ -187,7 +134,6 @@ function createUsersBootstrapContributor({
       const inheritedSurfaceAccess = normalizeObject(existingPayload?.surfaceAccess);
       let payload = createAnonymousBootstrapPayload({
         appState,
-        tenancyProfile: resolvedTenancyProfile,
         surfaceAccess: inheritedSurfaceAccess
       });
 
@@ -205,16 +151,8 @@ function createUsersBootstrapContributor({
             email: latestProfile.email,
             avatar: accountAvatarFormatter(latestProfile, userSettings)
           },
-          tenancy: resolvedTenancyProfile,
           app: appState,
-          workspaces: [],
-          pendingInvites: [],
-          activeWorkspace: null,
-          membership: null,
-          requestedWorkspace: null,
-          permissions: [],
           surfaceAccess: inheritedSurfaceAccess,
-          workspaceSettings: null,
           userSettings: mapUserSettingsBootstrap(userSettings),
           requestMeta: {
             hasRequest: Boolean(request)

package/src/shared/index.js

@@ -1,107 +1,10 @@
-import {
-  OWNER_ROLE_ID,
-  ADMIN_ROLE_ID,
-  MEMBER_ROLE_ID,
-  resolveRolePermissions,
-  listRoleDescriptors,
-  hasPermission
-} from "./roles.js";
-
-import {
-  DEFAULT_WORKSPACE_DARK_PALETTE,
-  DEFAULT_WORKSPACE_LIGHT_PALETTE,
-  DEFAULT_WORKSPACE_COLOR,
-  DEFAULT_USER_SETTINGS,
-  coerceWorkspaceColor,
-  coerceWorkspaceThemeColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor,
-  normalizeWorkspaceHexColor,
-  normalizeWorkspaceThemeMode,
-  resolveWorkspaceThemeDefaultPalette,
-  resolveWorkspaceThemePalettes,
-  WORKSPACE_THEME_MODE_DARK,
-  WORKSPACE_THEME_MODE_LIGHT,
-  resolveWorkspaceThemePalette
-} from "./settings.js";
-import {
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  normalizeTenancyMode,
-  WORKSPACE_SLUG_POLICY_NONE,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
-  WORKSPACE_SLUG_POLICY_USER_SELECTED,
-  resolveTenancyProfile,
-  isWorkspacesTenancyMode
-} from "./tenancyProfile.js";
+import { DEFAULT_USER_SETTINGS } from "./settings.js";
 
 const USERS_SHARED_API = Object.freeze({
-  OWNER_ROLE_ID,
-  ADMIN_ROLE_ID,
-  MEMBER_ROLE_ID,
-  resolveRolePermissions,
-  listRoleDescriptors,
-  hasPermission,
-  DEFAULT_WORKSPACE_LIGHT_PALETTE,
-  DEFAULT_WORKSPACE_DARK_PALETTE,
-  DEFAULT_WORKSPACE_COLOR,
-  DEFAULT_USER_SETTINGS,
-  coerceWorkspaceColor,
-  coerceWorkspaceThemeColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor,
-  WORKSPACE_THEME_MODE_LIGHT,
-  WORKSPACE_THEME_MODE_DARK,
-  normalizeWorkspaceThemeMode,
-  resolveWorkspaceThemeDefaultPalette,
-  resolveWorkspaceThemePalettes,
-  normalizeWorkspaceHexColor,
-  resolveWorkspaceThemePalette,
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  normalizeTenancyMode,
-  WORKSPACE_SLUG_POLICY_NONE,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
-  WORKSPACE_SLUG_POLICY_USER_SELECTED,
-  resolveTenancyProfile,
-  isWorkspacesTenancyMode
+  DEFAULT_USER_SETTINGS
 });
 
 export {
-  OWNER_ROLE_ID,
-  ADMIN_ROLE_ID,
-  MEMBER_ROLE_ID,
-  resolveRolePermissions,
-  listRoleDescriptors,
-  hasPermission,
-  DEFAULT_WORKSPACE_LIGHT_PALETTE,
-  DEFAULT_WORKSPACE_DARK_PALETTE,
-  DEFAULT_WORKSPACE_COLOR,
   DEFAULT_USER_SETTINGS,
-  coerceWorkspaceColor,
-  coerceWorkspaceThemeColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor,
-  WORKSPACE_THEME_MODE_LIGHT,
-  WORKSPACE_THEME_MODE_DARK,
-  normalizeWorkspaceThemeMode,
-  resolveWorkspaceThemeDefaultPalette,
-  resolveWorkspaceThemePalettes,
-  normalizeWorkspaceHexColor,
-  resolveWorkspaceThemePalette,
-  TENANCY_MODE_NONE,
-  TENANCY_MODE_PERSONAL,
-  TENANCY_MODE_WORKSPACES,
-  normalizeTenancyMode,
-  WORKSPACE_SLUG_POLICY_NONE,
-  WORKSPACE_SLUG_POLICY_IMMUTABLE_USERNAME,
-  WORKSPACE_SLUG_POLICY_USER_SELECTED,
-  resolveTenancyProfile,
-  isWorkspacesTenancyMode,
   USERS_SHARED_API
 };

package/src/shared/settings.js

@@ -1,23 +1,3 @@
-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",
@@ -32,104 +12,6 @@ const DEFAULT_USER_SETTINGS = Object.freeze({
   passwordSignInEnabled: true,
   passwordSetupRequired: false
 });
-
-function normalizeWorkspaceHexColor(value) {
-  const normalized = String(value || "").trim();
-  if (!HEX_COLOR_PATTERN.test(normalized)) {
-    return "";
-  }
-  return normalized.toUpperCase();
-}
-
-function coerceWorkspaceColor(value) {
-  return normalizeWorkspaceHexColor(value) || DEFAULT_WORKSPACE_COLOR;
-}
-
-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 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 coerceWorkspaceThemeColor(value, fallbackColor = DEFAULT_WORKSPACE_COLOR) {
-  return normalizeWorkspaceHexColor(value) || normalizeWorkspaceHexColor(fallbackColor) || DEFAULT_WORKSPACE_COLOR;
-}
-
-function coerceWorkspaceSecondaryColor(value, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
-  return coerceWorkspaceThemeColor(value, resolveWorkspaceThemeDefaultPalette(mode).secondaryColor);
-}
-
-function coerceWorkspaceSurfaceColor(value, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
-  return coerceWorkspaceThemeColor(value, resolveWorkspaceThemeDefaultPalette(mode).surfaceColor);
-}
-
-function coerceWorkspaceSurfaceVariantColor(value, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
-  return coerceWorkspaceThemeColor(value, resolveWorkspaceThemeDefaultPalette(mode).surfaceVariantColor);
-}
-
-function resolveWorkspaceThemePalette(input = {}, { mode = WORKSPACE_THEME_MODE_LIGHT } = {}) {
-  const source = input && typeof input === "object" ? input : {};
-  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({
-    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,
-  coerceWorkspaceColor,
-  coerceWorkspaceThemeColor,
-  coerceWorkspaceSecondaryColor,
-  coerceWorkspaceSurfaceColor,
-  coerceWorkspaceSurfaceVariantColor,
-  normalizeWorkspaceHexColor,
-  normalizeWorkspaceThemeMode,
-  resolveWorkspaceThemeDefaultPalette,
-  resolveWorkspaceThemePalettes,
-  WORKSPACE_THEME_MODE_DARK,
-  WORKSPACE_THEME_MODE_LIGHT,
-  resolveWorkspaceThemePalette
+  DEFAULT_USER_SETTINGS
 };