@jskit-ai/workspaces-core 0.1.137 → 0.1.138

package/src/server/workspaceMembers/workspaceMembersActions.js

@@ -3,8 +3,34 @@ import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { resolveWorkspace } from "../support/resolveWorkspace.js";
 import { resolveActionUser } from "../common/support/resolveActionUser.js";
 import { workspaceMembersResource } from "../../shared/resources/workspaceMembersResource.js";
+import {
+  INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE,
+  createWorkspaceEntityAndBootstrapEvents
+} from "../common/support/realtimeServiceEvents.js";
 import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
 
+const WORKSPACE_MEMBER_CHANGED_EVENTS = createWorkspaceEntityAndBootstrapEvents({
+  workspaceEntity: "member",
+  workspaceOperation: "updated",
+  workspaceRealtimeEvent: "workspace.members.changed"
+});
+
+const WORKSPACE_INVITE_CREATED_EVENTS = createWorkspaceEntityAndBootstrapEvents({
+  workspaceEntity: "invite",
+  workspaceOperation: "created",
+  workspaceRealtimeEvent: "workspace.invites.changed",
+  bootstrapEntityId: ({ result } = {}) => result?.value?.createdInviteId,
+  bootstrapAudience: INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE
+});
+
+const WORKSPACE_INVITE_REVOKED_EVENTS = createWorkspaceEntityAndBootstrapEvents({
+  workspaceEntity: "invite",
+  workspaceOperation: "updated",
+  workspaceRealtimeEvent: "workspace.invites.changed",
+  bootstrapEntityId: ({ result } = {}) => result?.value?.revokedInviteId,
+  bootstrapAudience: INVITE_RECIPIENT_BOOTSTRAP_AUDIENCE
+});
+
 const updateMemberRoleActionInput = composeSchemaDefinitions([
   workspaceSlugParamsValidator,
   workspaceMembersResource.operations.updateMemberRole.input
@@ -37,13 +63,13 @@ const revokeInviteActionInput = composeSchemaDefinitions([
   context: "workspaceMembersActions.revokeInviteActionInput"
 });
 
-const workspaceMembersActions = Object.freeze([
+const workspaceMembersActionSpecifications = Object.freeze([
   {
     id: "workspace.roles.list",
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.roles.view"]
@@ -55,8 +81,8 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.roles.list"
     },
     observability: {},
-    async execute(_input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.listRoles({ context }));
+    async run(workspaceMembersService, _input, context) {
+      return returnJsonApiData(await workspaceMembersService.listRoles({ context }));
     }
   },
   {
@@ -64,7 +90,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.view"]
@@ -76,8 +102,8 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.members.list"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.listMembers(resolveWorkspace(context, input), {
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.listMembers(resolveWorkspace(context, input), {
         context
       }));
     }
@@ -87,7 +113,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.manage"]
@@ -99,8 +125,9 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.member.role.update"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.updateMemberRole(resolveWorkspace(context, input), {
+    events: WORKSPACE_MEMBER_CHANGED_EVENTS,
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.updateMemberRole(resolveWorkspace(context, input), {
         memberUserId: input.memberUserId,
         roleSid: input.roleSid
       }, {
@@ -113,7 +140,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.manage"]
@@ -125,8 +152,9 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.member.remove"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.removeMember(resolveWorkspace(context, input), {
+    events: WORKSPACE_MEMBER_CHANGED_EVENTS,
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.removeMember(resolveWorkspace(context, input), {
         memberUserId: input.memberUserId
       }, {
         context
@@ -138,7 +166,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.view"]
@@ -150,8 +178,8 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.invites.list"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.listInvites(resolveWorkspace(context, input), {
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.listInvites(resolveWorkspace(context, input), {
         context
       }));
     }
@@ -161,7 +189,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "assistant_tool", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.members.invite"]
@@ -173,13 +201,14 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.invite.create"
     },
     observability: {},
+    events: WORKSPACE_INVITE_CREATED_EVENTS,
     extensions: {
       assistant: {
         description: "Invite a person to the workspace."
       }
     },
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.createInvite(
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.createInvite(
         resolveWorkspace(context, input),
         resolveActionUser(context, input),
         {
@@ -197,7 +226,7 @@ const workspaceMembersActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.invites.revoke"]
@@ -209,12 +238,23 @@ const workspaceMembersActions = Object.freeze([
       actionName: "workspace.invite.revoke"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.workspaceMembersService.revokeInvite(resolveWorkspace(context, input), input.inviteId, {
+    events: WORKSPACE_INVITE_REVOKED_EVENTS,
+    async run(workspaceMembersService, input, context) {
+      return returnJsonApiData(await workspaceMembersService.revokeInvite(resolveWorkspace(context, input), input.inviteId, {
         context
       }));
     }
   }
 ]);
 
-export { workspaceMembersActions };
+function buildWorkspaceMembersActions({ workspaceMembersService } = {}) {
+  if (!workspaceMembersService) throw new TypeError("buildWorkspaceMembersActions requires workspaceMembersService.");
+  return workspaceMembersActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(workspaceMembersService, input, context);
+    }
+  }));
+}
+
+export { workspaceMembersActionSpecifications, buildWorkspaceMembersActions };

package/src/server/workspacePendingInvitations/bootWorkspacePendingInvitations.js

@@ -24,13 +24,11 @@ function resolveInviteResolutionRecordId(record = {}) {
   return "workspace-invitation";
 }
 
-function bootWorkspacePendingInvitations(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootWorkspacePendingInvitations requires application make().");
+function registerWorkspacePendingInvitationsRoutes(router) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerWorkspacePendingInvitationsRoutes requires router.register().");
   }
 
-  const router = app.make("jskit.http.router");
-
   router.register(
     "GET",
     "/api/workspace/invitations/resolve",
@@ -110,4 +108,4 @@ function bootWorkspacePendingInvitations(app) {
   );
 }
 
-export { bootWorkspacePendingInvitations };
+export { registerWorkspacePendingInvitationsRoutes };

package/src/server/workspacePendingInvitations/workspacePendingInvitationsActions.js

@@ -4,15 +4,21 @@ import {
 import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { workspaceMembersResource } from "../../shared/resources/workspaceMembersResource.js";
 import { workspacePendingInvitationsResource } from "../../shared/resources/workspacePendingInvitationsResource.js";
+import { createInviteDecisionEvents } from "../common/support/realtimeServiceEvents.js";
 import { resolveActionUser } from "../common/support/resolveActionUser.js";
 
-const workspacePendingInvitationsActions = Object.freeze([
+const WORKSPACE_INVITE_DECISION_EVENTS = createInviteDecisionEvents();
+
+const workspacePendingInvitationsActionSpecifications = Object.freeze([
   {
     id: "workspace.invitation.resolve",
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
+    permission: {
+      require: "none"
+    },
     input: workspacePendingInvitationsResource.operations.resolve.query,
     output: null,
     idempotency: "none",
@@ -20,9 +26,9 @@ const workspacePendingInvitationsActions = Object.freeze([
       actionName: "workspace.invitation.resolve"
     },
     observability: {},
-    async execute(input, context, deps) {
+    async run(workspacePendingInvitationsService, input, context) {
       return returnJsonApiData(
-        await deps.workspacePendingInvitationsService.resolveInviteByToken(input?.token, {
+        await workspacePendingInvitationsService.resolveInviteByToken(input?.token, {
           context
         })
       );
@@ -33,7 +39,7 @@ const workspacePendingInvitationsActions = Object.freeze([
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -44,9 +50,9 @@ const workspacePendingInvitationsActions = Object.freeze([
       actionName: "workspace.invitations.pending.list"
     },
     observability: {},
-    async execute(input, context, deps) {
+    async run(workspacePendingInvitationsService, input, context) {
       return returnJsonApiData({
-        pendingInvites: await deps.workspacePendingInvitationsService.listPendingInvitesForUser(resolveActionUser(context, input), {
+        pendingInvites: await workspacePendingInvitationsService.listPendingInvitesForUser(resolveActionUser(context, input), {
           context
         })
       });
@@ -57,7 +63,7 @@ const workspacePendingInvitationsActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "enabled",
+    surfaces: ["*"],
     permission: {
       require: "authenticated"
     },
@@ -68,12 +74,13 @@ const workspacePendingInvitationsActions = Object.freeze([
       actionName: "workspace.invite.redeem"
     },
     observability: {},
-    async execute(input, context, deps) {
+    events: WORKSPACE_INVITE_DECISION_EVENTS,
+    async run(workspacePendingInvitationsService, input, context) {
       const payload = input || {};
       const user = resolveActionUser(context, input);
 
       if (payload.decision === "accept") {
-        return returnJsonApiData(await deps.workspacePendingInvitationsService.acceptInviteByToken({
+        return returnJsonApiData(await workspacePendingInvitationsService.acceptInviteByToken({
           user,
           token: payload.token
         }, {
@@ -81,7 +88,7 @@ const workspacePendingInvitationsActions = Object.freeze([
         }));
       }
 
-      return returnJsonApiData(await deps.workspacePendingInvitationsService.refuseInviteByToken({
+      return returnJsonApiData(await workspacePendingInvitationsService.refuseInviteByToken({
         user,
         token: payload.token
       }, {
@@ -91,4 +98,16 @@ const workspacePendingInvitationsActions = Object.freeze([
   }
 ]);
 
-export { workspacePendingInvitationsActions };
+function buildWorkspacePendingInvitationsActions({ workspacePendingInvitationsService } = {}) {
+  if (!workspacePendingInvitationsService) {
+    throw new TypeError("buildWorkspacePendingInvitationsActions requires workspacePendingInvitationsService.");
+  }
+  return workspacePendingInvitationsActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(workspacePendingInvitationsService, input, context);
+    }
+  }));
+}
+
+export { workspacePendingInvitationsActionSpecifications, buildWorkspacePendingInvitationsActions };

package/src/server/workspaceSettings/bootWorkspaceSettings.js

@@ -19,14 +19,11 @@ function resolveWorkspaceSettingsRecordId(record = {}, context = {}) {
   throw new Error("Workspace settings JSON:API response requires workspace id.");
 }
 
-function bootWorkspaceSettings(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootWorkspaceSettings requires application make().");
+function registerWorkspaceSettingsRoutes(router, { config = {} } = {}) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerWorkspaceSettingsRoutes requires router.register().");
   }
-
-  const router = app.make("jskit.http.router");
-  const appConfig = typeof app.has === "function" && app.has("appConfig") ? app.make("appConfig") : {};
-  const workspaceRouteSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig);
+  const workspaceRouteSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(config);
 
   router.register(
     "GET",
@@ -92,4 +89,4 @@ function bootWorkspaceSettings(app) {
   );
 }
 
-export { bootWorkspaceSettings };
+export { registerWorkspaceSettingsRoutes };

package/src/server/workspaceSettings/workspaceSettingsActions.js

@@ -2,8 +2,15 @@ import { composeSchemaDefinitions } from "@jskit-ai/kernel/shared/validators";
 import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { workspaceSettingsResource } from "../../shared/resources/workspaceSettingsResource.js";
 import { workspaceSlugParamsValidator } from "../common/validators/routeParamsValidator.js";
+import { createWorkspaceEntityAndBootstrapEvents } from "../common/support/realtimeServiceEvents.js";
 import { resolveWorkspace } from "../support/resolveWorkspace.js";
 
+const WORKSPACE_SETTINGS_CHANGED_EVENTS = createWorkspaceEntityAndBootstrapEvents({
+  workspaceEntity: "settings",
+  workspaceOperation: "updated",
+  workspaceRealtimeEvent: "workspace.settings.changed"
+});
+
 const workspaceSettingsUpdateInputValidator = composeSchemaDefinitions([
   workspaceSlugParamsValidator,
   workspaceSettingsResource.operations.patch.body
@@ -12,13 +19,13 @@ const workspaceSettingsUpdateInputValidator = composeSchemaDefinitions([
   context: "workspaceSettingsActions.workspaceSettingsUpdateInputValidator"
 });
 
-const workspaceSettingsActions = Object.freeze([
+const workspaceSettingsActionSpecifications = Object.freeze([
   {
     id: "workspace.settings.read",
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "any",
       permissions: ["workspace.settings.view", "workspace.settings.update"]
@@ -30,8 +37,8 @@ const workspaceSettingsActions = Object.freeze([
       actionName: "workspace.settings.read"
     },
     observability: {},
-    async execute(input, context, deps) {
-      const response = await deps.workspaceSettingsService.getWorkspaceSettings(resolveWorkspace(context, input), {
+    async run(workspaceSettingsService, input, context) {
+      const response = await workspaceSettingsService.getWorkspaceSettings(resolveWorkspace(context, input), {
         context
       });
 
@@ -43,7 +50,7 @@ const workspaceSettingsActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "assistant_tool", "automation", "internal"],
-    surfacesFrom: "workspace",
+    surfaces: ["*"],
     permission: {
       require: "all",
       permissions: ["workspace.settings.update"]
@@ -55,14 +62,15 @@ const workspaceSettingsActions = Object.freeze([
       actionName: "workspace.settings.update"
     },
     observability: {},
+    events: WORKSPACE_SETTINGS_CHANGED_EVENTS,
     extensions: {
       assistant: {
         description: "Update workspace settings."
       }
     },
-    async execute(input, context, deps) {
+    async run(workspaceSettingsService, input, context) {
       const { workspaceSlug, ...patch } = input;
-      const response = await deps.workspaceSettingsService.updateWorkspaceSettings(
+      const response = await workspaceSettingsService.updateWorkspaceSettings(
         resolveWorkspace(context, input),
         patch,
         {
@@ -75,4 +83,14 @@ const workspaceSettingsActions = Object.freeze([
   }
 ]);
 
-export { workspaceSettingsActions };
+function buildWorkspaceSettingsActions({ workspaceSettingsService } = {}) {
+  if (!workspaceSettingsService) throw new TypeError("buildWorkspaceSettingsActions requires workspaceSettingsService.");
+  return workspaceSettingsActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(workspaceSettingsService, input, context);
+    }
+  }));
+}
+
+export { workspaceSettingsActionSpecifications, buildWorkspaceSettingsActions };

package/src/server/workspaceSettings/workspaceSettingsRepository.js

@@ -35,7 +35,7 @@ function pickPatchFields(source = {}) {
   return patch;
 }
 
-function createDefaultWorkspaceSettingsCreatePayload(workspaceId) {
+function createDefaultWorkspaceSettingsCreatePayload(workspaceId, defaultInvitesEnabled) {
   const palettes = resolveWorkspaceThemePalettes({});
 
   return {
@@ -48,11 +48,11 @@ function createDefaultWorkspaceSettingsCreatePayload(workspaceId) {
     darkSecondaryColor: palettes.dark.secondaryColor,
     darkSurfaceColor: palettes.dark.surfaceColor,
     darkSurfaceVariantColor: palettes.dark.surfaceVariantColor,
-    invitesEnabled: true
+    invitesEnabled: defaultInvitesEnabled
   };
 }
 
-function createRepository({ api, knex } = {}) {
+function createRepository({ api, knex, defaultInvitesEnabled = true } = {}) {
   if (!api?.resources?.workspaceSettings) {
     throw new TypeError("workspaceSettingsRepository requires json-rest-api workspaceSettings resource.");
   }
@@ -103,7 +103,7 @@ function createRepository({ api, knex } = {}) {
         {
           inputRecord: createJsonApiInputRecord(
             RESOURCE_TYPE,
-            createDefaultWorkspaceSettingsCreatePayload(normalizedWorkspaceId),
+            createDefaultWorkspaceSettingsCreatePayload(normalizedWorkspaceId, defaultInvitesEnabled === true),
             {
               id: normalizedWorkspaceId
             }

package/test/exportsContract.test.js

@@ -14,7 +14,8 @@ test("workspaces-core exports are explicit and aligned with production usage", (
     packageDir: PACKAGE_DIR,
     packageId: "@jskit-ai/workspaces-core",
     requiredExports: [
-      "./server/WorkspacesCoreServiceProvider",
+      "./server/WorkspacesFeature",
+      "./server/WorkspacesIntegrationsProvider",
       "./server/validators/routeParamsValidator",
       "./server/support/workspaceRouteInput",
       "./shared/resources/workspaceResource",

package/test/featureRuntime.test.js

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createAuthExtensions } from "@jskit-ai/auth-core/server/authExtensions";
+import { createActionProvider } from "@jskit-ai/kernel/server/actions";
+import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { createBootstrapRuntime } from "@jskit-ai/kernel/server/runtime";
+import { createUsersExtensions } from "@jskit-ai/users-core/server/usersExtensions";
+import { WorkspacesFeature } from "../src/server/WorkspacesFeature.js";
+import { WorkspacesIntegrationsProvider } from "../src/server/WorkspacesIntegrationsProvider.js";
+
+function createJsonRestApiFixture() {
+  const resources = {};
+  return {
+    resources,
+    async addResource(scopeName) {
+      resources[scopeName] = Object.freeze({
+        query: async () => ({ data: [] }),
+        post: async () => null,
+        patch: async () => null
+      });
+    }
+  };
+}
+
+function runtimeConfig() {
+  return {
+    appPublicUrl: "http://localhost:5173",
+    tenancyMode: "workspaces",
+    tenancyPolicy: { workspace: { allowSelfCreate: true } },
+    workspaceInvitations: { enabled: true },
+    workspaceMembers: { defaults: { inviteExpiresInMs: 86400000 } },
+    workspaceSettings: { defaults: { invitesEnabled: true } },
+    surfaceDefaultId: "customer",
+    surfaceDefinitions: {
+      customer: { id: "customer", requiresWorkspace: true, accessPolicyId: "workspace_authenticated" }
+    },
+    surfaceAccessPolicies: {
+      workspace_authenticated: { requireWorkspaceMembership: false }
+    },
+    roleCatalog: {
+      workspace: { defaultInviteRole: "member" },
+      roles: {
+        owner: { permissions: ["workspace.*"] },
+        member: { assignable: true, permissions: ["workspace.settings.view"] }
+      }
+    }
+  };
+}
+
+test("WorkspacesFeature assembles workspace behavior and explicit integrations", async () => {
+  const routes = [];
+  const visibilityResolvers = [];
+  const bootstrap = createBootstrapRuntime();
+  const authExtensions = createAuthExtensions();
+  const usersExtensions = createUsersExtensions();
+  const jsonRestApi = createJsonRestApiFixture();
+  let workspaces = null;
+  let actionCatalogue = null;
+  const probe = defineProvider({
+    id: "test.workspaces.probe",
+    requires: {
+      actions: "runtime.actions",
+      workspaceCapability: "workspaces.core"
+    },
+    setup({ actions, workspaceCapability }) {
+      actionCatalogue = actions;
+      workspaces = workspaceCapability;
+      return {};
+    }
+  });
+  const runtime = createCapabilityRuntime({
+    inputs: {
+      "auth.extensions": authExtensions,
+      "runtime.bootstrap": bootstrap,
+      "runtime.config": runtimeConfig(),
+      "runtime.database": { knex() {} },
+      "runtime.env": {},
+      "runtime.http": {
+        router: {
+          register(method, path) {
+            routes.push(`${method} ${path}`);
+          }
+        },
+        registerVisibilityResolver(resolver) {
+          visibilityResolvers.push(resolver);
+        }
+      },
+      "runtime.json-rest-api": jsonRestApi,
+      "users.core": {
+        repositories: {
+          userProfiles: { async findById() { return null; } }
+        }
+      },
+      "users.extensions": usersExtensions
+    },
+    providers: [createActionProvider(), WorkspacesFeature, WorkspacesIntegrationsProvider, probe]
+  });
+
+  await runtime.start();
+
+  assert.deepEqual(Object.keys(jsonRestApi.resources).sort(), [
+    "workspaceInvites",
+    "workspaceMemberships",
+    "workspaceSettings",
+    "workspaces"
+  ]);
+  assert.equal(typeof workspaces.services.directory.resolveWorkspaceContextForUserBySlug, "function");
+  assert.equal(routes.includes("POST /api/workspaces"), true);
+  assert.equal(routes.includes("GET /api/workspace/invitations/resolve"), true);
+  assert.equal(actionCatalogue.listDefinitions().length, 16);
+  assert.deepEqual(bootstrap.diagnostics().contributorIds, ["workspaces.bootstrap"]);
+  assert.deepEqual(visibilityResolvers.map((entry) => entry.id), ["workspaces.visibility"]);
+  assert.deepEqual(usersExtensions.diagnostics().profileSyncLifecycleContributorIds, ["workspaces.provisioning"]);
+  assert.deepEqual(authExtensions.diagnostics().invitationContextResolverIds, ["workspaces.invitation"]);
+  assert.deepEqual(authExtensions.diagnostics().policyContextResolverIds, ["workspaces.policy"]);
+});