@jskit-ai/users-web 0.1.53 → 0.1.55

package/src/client/composables/useAccountSettingsRuntime.js

@@ -1,29 +1,25 @@
 import { computed, onBeforeUnmount, onMounted, reactive, ref, watch } from "vue";
 import { useQueryClient } from "@tanstack/vue-query";
 import { useTheme } from "vuetify";
-import { useRoute, useRouter } from "vue-router";
+import { useRoute } from "vue-router";
 import {
   useWebPlacementContext,
   resolveSurfaceNavigationTargetFromPlacementContext
 } from "@jskit-ai/shell-web/client/placement";
 import { useShellWebErrorRuntime } from "@jskit-ai/shell-web/client/error";
 import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
+import { ROUTE_VISIBILITY_PUBLIC } from "@jskit-ai/kernel/shared/support/visibility";
 import { userProfileResource } from "@jskit-ai/users-core/shared/resources/userProfileResource";
 import { userSettingsResource } from "@jskit-ai/users-core/shared/resources/userSettingsResource";
-import { USERS_ROUTE_VISIBILITY_PUBLIC } from "@jskit-ai/users-core/shared/support/usersVisibility";
 import {
   persistThemePreference,
   resolveThemeNameForPreference,
   setVuetifyThemeName
 } from "../lib/theme.js";
-import {
-  useWorkspaceSurfaceId
-} from "./useWorkspaceSurfaceId.js";
 import { useAddEdit } from "./records/useAddEdit.js";
 import { useCommand } from "./useCommand.js";
 import { useView } from "./records/useView.js";
-import { usePaths } from "./usePaths.js";
-import { resolveAccountSettingsPathFromPlacementContext } from "../lib/workspaceSurfacePaths.js";
+import { resolveSurfacePathFromPlacementContext } from "@jskit-ai/shell-web/client/placement";
 import {
   ACCOUNT_SETTINGS_DEFAULTS,
   AVATAR_DEFAULT_SIZE,
@@ -37,19 +33,15 @@ import {
 } from "./account-settings/accountSettingsRuntimeConstants.js";
 import {
   normalizeAvatarSize,
-  normalizePendingInvite,
   normalizeReturnToPath,
   normalizeSettingsPayload,
   resolveAllowedReturnToOrigins
 } from "./account-settings/accountSettingsRuntimeHelpers.js";
 import { createAccountSettingsAvatarUploadRuntime } from "./account-settings/accountSettingsAvatarUploadRuntime.js";
-import { createAccountSettingsInvitesRuntime } from "./account-settings/accountSettingsInvitesRuntime.js";
 
 function useAccountSettingsRuntime() {
   const route = useRoute();
-  const router = useRouter();
   const { context: placementContext } = useWebPlacementContext();
-  const paths = usePaths();
   const queryClient = useQueryClient();
   const errorRuntime = useShellWebErrorRuntime();
   const vuetifyTheme = useTheme();
@@ -58,11 +50,12 @@ function useAccountSettingsRuntime() {
   const accountProfileWriteQueryKey = ["users-web", "settings", "account-profile-write"];
   const accountPreferencesWriteQueryKey = ["users-web", "settings", "account-preferences-write"];
   const accountNotificationsWriteQueryKey = ["users-web", "settings", "account-notifications-write"];
-  const pendingInvitesQueryKey = ["users-web", "settings", "pending-invites"];
   const sessionQueryKey = Object.freeze(["users-web", "session", "csrf"]);
-  const OWNERSHIP_PUBLIC = USERS_ROUTE_VISIBILITY_PUBLIC;
+  const OWNERSHIP_PUBLIC = ROUTE_VISIBILITY_PUBLIC;
 
-  const accountSettingsPath = computed(() => resolveAccountSettingsPathFromPlacementContext(placementContext.value));
+  const accountSettingsPath = computed(() =>
+    resolveSurfacePathFromPlacementContext(placementContext.value, "account", "/")
+  );
   const allowedReturnToOrigins = computed(() => resolveAllowedReturnToOrigins(placementContext.value));
   const backTarget = computed(() =>
     normalizeReturnToPath(route?.query?.returnTo, {
@@ -107,20 +100,7 @@ function useAccountSettingsRuntime() {
     version: null
   });
 
-  const pendingInvitesModel = reactive({
-    pendingInvites: [],
-    workspaceInvitesEnabled: false
-  });
-
   const selectedAvatarFileName = ref("");
-  const inviteAction = ref({
-    token: "",
-    decision: ""
-  });
-  const redeemInviteModel = reactive({
-    token: "",
-    decision: ""
-  });
 
   const profileInitials = computed(() => {
     const source = String(profileForm.displayName || profileForm.email || "U").trim();
@@ -211,41 +191,6 @@ function useAccountSettingsRuntime() {
     mapLoadedToModel: mapAccountSettingsPayload
   });
 
-  const pendingInvitesView = useView({
-    ownershipFilter: OWNERSHIP_PUBLIC,
-    apiSuffix: "/bootstrap",
-    queryKeyFactory: () => pendingInvitesQueryKey,
-    realtime: {
-      event: "workspace.invitations.pending.changed"
-    },
-    fallbackLoadError: "Unable to load invitations.",
-    model: pendingInvitesModel,
-    mapLoadedToModel: (model, payload = {}) => {
-      model.workspaceInvitesEnabled = payload?.app?.features?.workspaceInvites === true;
-      model.pendingInvites = model.workspaceInvitesEnabled
-        ? (Array.isArray(payload?.pendingInvites) ? payload.pendingInvites : [])
-          .map(normalizePendingInvite)
-          .filter(Boolean)
-        : [];
-    }
-  });
-
-  const redeemInviteCommand = useCommand({
-    ownershipFilter: OWNERSHIP_PUBLIC,
-    apiSuffix: "/workspace/invitations/redeem",
-    writeMethod: "POST",
-    fallbackRunError: "Unable to respond to invitation.",
-    suppressSuccessMessage: true,
-    model: redeemInviteModel,
-    buildRawPayload: (model) => ({
-      token: String(model.token || "").trim(),
-      decision: String(model.decision || "").trim().toLowerCase()
-    }),
-    messages: {
-      error: "Unable to respond to invitation."
-    }
-  });
-
   const profileAddEdit = useAddEdit({
     ownershipFilter: OWNERSHIP_PUBLIC,
     resource: userProfileResource,
@@ -349,91 +294,10 @@ function useAccountSettingsRuntime() {
 
   const loadingSettings = computed(() => Boolean(settingsView.isLoading));
   const refreshingSettings = computed(() => Boolean(settingsView.isRefetching));
-  const invitesAvailable = computed(() => pendingInvitesModel.workspaceInvitesEnabled === true);
-  const loadingInvites = computed(() => Boolean(pendingInvitesView.isLoading));
-  const refreshingInvites = computed(() => Boolean(pendingInvitesView.isRefetching));
-  const pendingInvites = computed(() => {
-    return Array.isArray(pendingInvitesModel.pendingInvites) ? pendingInvitesModel.pendingInvites : [];
-  });
-  const isResolvingInvite = computed(() => Boolean(redeemInviteCommand.isRunning.value));
-
-  const { workspaceSurfaceId } = useWorkspaceSurfaceId({
-    route,
-    placementContext
-  });
-
-  function workspaceHomePath(workspaceSlug) {
-    const normalizedSlug = String(workspaceSlug || "").trim();
-    if (!normalizedSlug || !workspaceSurfaceId.value) {
-      return "";
-    }
-
-    return paths.page("/", {
-      surface: workspaceSurfaceId.value,
-      workspaceSlug: normalizedSlug,
-      mode: "workspace"
-    });
-  }
-
   async function submitProfile() {
     await profileAddEdit.submit();
   }
 
-  async function openWorkspace(workspaceSlug) {
-    const targetPath = workspaceHomePath(workspaceSlug);
-    if (!targetPath) {
-      reportAccountFeedback({
-        message: "Workspace surface is not configured.",
-        severity: "error",
-        channel: "banner",
-        dedupeKey: "users-web.account-settings-runtime:workspace-surface-missing"
-      });
-      return;
-    }
-
-    try {
-      const navigationTarget = resolveSurfaceNavigationTargetFromPlacementContext(placementContext.value, {
-        path: targetPath,
-        surfaceId: workspaceSurfaceId.value
-      });
-      if (navigationTarget.sameOrigin) {
-        await router.push(navigationTarget.href);
-      } else if (typeof window === "object" && window?.location && typeof window.location.assign === "function") {
-        window.location.assign(navigationTarget.href);
-      } else {
-        throw new Error("Cross-origin navigation is unavailable in this environment.");
-      }
-    } catch (error) {
-      reportAccountFeedback({
-        message: String(error?.message || "Unable to open workspace."),
-        severity: "error",
-        channel: "banner",
-        dedupeKey: `users-web.account-settings-runtime:open-workspace:${String(workspaceSlug || "").trim()}`
-      });
-    }
-  }
-
-  const invitesRuntime = createAccountSettingsInvitesRuntime({
-    invitesAvailable,
-    isResolvingInvite,
-    inviteAction,
-    redeemInviteModel,
-    redeemInviteCommand,
-    pendingInvites,
-    pendingInvitesModel,
-    pendingInvitesView,
-    openWorkspace,
-    reportAccountFeedback
-  });
-
-  function acceptInvite(invite) {
-    return invitesRuntime.accept(invite);
-  }
-
-  function refuseInvite(invite) {
-    return invitesRuntime.refuse(invite);
-  }
-
   function openAvatarEditor() {
     avatarUploadRuntime.openEditor();
   }
@@ -508,17 +372,6 @@ function useAccountSettingsRuntime() {
     submit: submitNotifications
   });
 
-  const invites = Object.freeze({
-    isAvailable: invitesAvailable,
-    items: pendingInvites,
-    isLoading: loadingInvites,
-    isRefetching: refreshingInvites,
-    isResolving: isResolvingInvite,
-    action: inviteAction,
-    accept: acceptInvite,
-    refuse: refuseInvite
-  });
-
   return Object.freeze({
     backTarget,
     backNavigationTarget,
@@ -526,8 +379,7 @@ function useAccountSettingsRuntime() {
     refreshingSettings,
     profile,
     preferences,
-    notifications,
-    invites
+    notifications
   });
 }
 

package/src/client/composables/useCommand.js

@@ -1,5 +1,5 @@
 import { proxyRefs } from "vue";
-import { USERS_ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/users-core/shared/support/usersVisibility";
+import { ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/kernel/shared/support/visibility";
 import { useCommandCore } from "./runtime/useCommandCore.js";
 import { useEndpointResource } from "./runtime/useEndpointResource.js";
 import { useOperationScope } from "./internal/useOperationScope.js";
@@ -11,7 +11,7 @@ import {
 } from "./runtime/operationUiHelpers.js";
 
 function useCommand({
-  ownershipFilter = USERS_ROUTE_VISIBILITY_WORKSPACE,
+  ownershipFilter = ROUTE_VISIBILITY_WORKSPACE,
   surfaceId = "",
   access = "auto",
   apiSuffix = "",

package/src/client/composables/useCrudListParentTitle.js

@@ -79,12 +79,12 @@ function useCrudListParentTitle({
     readEnabled: shouldLoadParentRecord,
     recordIdParam: normalizeText(initialParentDescriptor.routeParamKey) || "recordId",
     includeRecordIdInQueryKey: true,
-    queryKeyFactory: (surfaceId = "", workspaceSlug = "") => [
+    queryKeyFactory: (surfaceId = "", scopeParamValue = "") => [
       ...normalizedQueryKeyPrefix,
       normalizeText(initialParentDescriptor.relationNamespace),
       normalizeText(initialParentDescriptor.routeParamKey),
       String(surfaceId || ""),
-      String(workspaceSlug || "")
+      String(scopeParamValue || "")
     ],
     placementSource,
     fallbackLoadError,

package/src/client/composables/usePaths.js

@@ -1,9 +1,9 @@
 import { computed, unref } from "vue";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { resolveApiBasePath } from "@jskit-ai/users-core/shared/support/usersApiPaths";
-import { useWorkspaceRouteContext } from "./useWorkspaceRouteContext.js";
-import { useWorkspaceLinkResolver } from "../lib/workspaceLinkResolver.js";
-import { surfaceRequiresWorkspaceFromPlacementContext } from "../lib/workspaceSurfaceContext.js";
+import { resolveScopedApiBasePath } from "@jskit-ai/kernel/shared/surface";
+import { resolveSurfaceDefinitionFromPlacementContext } from "@jskit-ai/shell-web/client/placement";
+import { useShellLinkResolver } from "@jskit-ai/shell-web/client/navigation/linkResolver";
+import { useSurfaceRouteContext } from "./useSurfaceRouteContext.js";
 
 function normalizePathSuffix(value = "") {
   const raw = normalizeText(unref(value));
@@ -28,23 +28,43 @@ function resolveSurfaceId(value, fallback = "") {
   return "";
 }
 
-function resolveWorkspaceSlug(value, fallback = "") {
-  const normalized = normalizeText(unref(value));
-  if (normalized) {
-    return normalized;
+function resolveDefaultSurfaceIdFromPlacementContext(placementContext = null) {
+  return resolveSurfaceId(placementContext?.surfaceConfig?.defaultSurfaceId, "");
+}
+
+function normalizeRouteParams(params = null) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return {};
   }
 
-  return normalizeText(unref(fallback));
+  const output = {};
+  for (const [rawKey, rawValue] of Object.entries(params)) {
+    const key = normalizeText(rawKey);
+    if (!key) {
+      continue;
+    }
+
+    const value = Array.isArray(rawValue) ? rawValue[0] : rawValue;
+    const normalizedValue = normalizeText(value);
+    if (!normalizedValue) {
+      continue;
+    }
+    output[key] = normalizedValue;
+  }
+  return output;
 }
 
-function resolveDefaultSurfaceIdFromPlacementContext(placementContext = null) {
-  return resolveSurfaceId(placementContext?.surfaceConfig?.defaultSurfaceId, "");
+function resolveRouteParams(baseParams = {}, overrideParams = null) {
+  return {
+    ...normalizeRouteParams(baseParams),
+    ...normalizeRouteParams(overrideParams)
+  };
 }
 
 function usePaths({ routeContext: sourceRouteContext = null } = {}) {
-  const routeContext = sourceRouteContext || useWorkspaceRouteContext();
-  const workspaceLinkResolver = useWorkspaceLinkResolver();
-  const workspaceSlug = computed(() => String(routeContext.workspaceSlugFromRoute.value || "").trim());
+  const routeContext = sourceRouteContext || useSurfaceRouteContext();
+  const shellLinkResolver = useShellLinkResolver();
+  const routeParams = computed(() => normalizeRouteParams(routeContext.route?.params));
 
   function page(relativePath = "/", options = {}) {
     const source = options && typeof options === "object" && !Array.isArray(options) ? options : {};
@@ -54,13 +74,12 @@ function usePaths({ routeContext: sourceRouteContext = null } = {}) {
     if (!surface) {
       return "";
     }
-    const nextWorkspaceSlug = resolveWorkspaceSlug(source.workspaceSlug, workspaceSlug.value);
-    const mode = normalizeText(source.mode).toLowerCase() || "auto";
-
-    return workspaceLinkResolver.resolve(relativePath, {
+    return shellLinkResolver.resolve(relativePath, {
       surface,
-      workspaceSlug: nextWorkspaceSlug,
-      mode
+      explicitTo: source.explicitTo,
+      surfaceRelativePath: source.surfaceRelativePath,
+      params: resolveRouteParams(routeParams.value, source.params),
+      strictParams: source.strictParams !== false
     });
   }
 
@@ -70,36 +89,29 @@ function usePaths({ routeContext: sourceRouteContext = null } = {}) {
       resolveSurfaceId(source.surface, routeContext.currentSurfaceId.value) ||
       resolveDefaultSurfaceIdFromPlacementContext(routeContext.placementContext.value);
     const suffix = normalizePathSuffix(relativePath);
-    const workspaceScoped = surfaceRequiresWorkspaceFromPlacementContext(routeContext.placementContext.value, surface);
 
     if (!suffix) {
       throw new TypeError("usePaths().api(relativePath) requires a non-empty relativePath.");
     }
 
-    const templatePath = resolveApiBasePath({
-      surfaceRequiresWorkspace: workspaceScoped,
-      relativePath: suffix
-    });
-
-    if (workspaceScoped) {
-      const nextWorkspaceSlug = resolveWorkspaceSlug(source.workspaceSlug, workspaceSlug.value);
-      if (!nextWorkspaceSlug) {
-        throw new Error(
-          `usePaths().api(${suffix}) requires workspace slug for workspace surface "${surface || "<unknown>"}".`
-        );
-      }
-
-      return templatePath.replace(":workspaceSlug", nextWorkspaceSlug);
-    }
+    const routeBase = resolveSurfaceDefinitionFromPlacementContext(
+      routeContext.placementContext.value,
+      surface
+    )?.routeBase || "/";
 
-    return templatePath;
+    return resolveScopedApiBasePath({
+      routeBase,
+      relativePath: suffix,
+      params: resolveRouteParams(routeParams.value, source.params),
+      strictParams: source.strictParams !== false
+    });
   }
 
   return Object.freeze({
     route: routeContext.route,
     placementContext: routeContext.placementContext,
     currentSurfaceId: routeContext.currentSurfaceId,
-    workspaceSlug,
+    routeParams,
     page,
     api
   });

package/src/client/composables/useScopeRuntime.js

@@ -1,10 +1,12 @@
 import { computed } from "vue";
-import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
-import { USERS_ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/users-core/shared/support/usersVisibility";
+import { normalizeSurfaceId, resolveScopedRouteBase } from "@jskit-ai/kernel/shared/surface";
+import {
+  ROUTE_VISIBILITY_WORKSPACE
+} from "@jskit-ai/kernel/shared/support/visibility";
 import { useAccess } from "./useAccess.js";
-import { useWorkspaceRouteContext } from "./useWorkspaceRouteContext.js";
+import { useSurfaceRouteContext } from "./useSurfaceRouteContext.js";
 import { usePaths } from "./usePaths.js";
-import { surfaceRequiresWorkspaceFromPlacementContext } from "../lib/workspaceSurfaceContext.js";
+import { resolveSurfaceDefinitionFromPlacementContext } from "@jskit-ai/shell-web/client/placement";
 import {
   asPlainObject,
   ensureAccessModeCompatibility,
@@ -12,9 +14,15 @@ import {
   normalizeOwnershipFilter,
   resolveApiSuffix
 } from "./support/scopeHelpers.js";
+import { extractRouteParamNames, toRouteParamValue } from "./support/routeTemplateHelpers.js";
+
+function resolveScopedRouteParamNames(placementContext = null, surfaceId = "") {
+  const routeBase = resolveSurfaceDefinitionFromPlacementContext(placementContext, surfaceId)?.routeBase || "/";
+  return extractRouteParamNames(resolveScopedRouteBase(routeBase));
+}
 
 function useScopeRuntime({
-  ownershipFilter = USERS_ROUTE_VISIBILITY_WORKSPACE,
+  ownershipFilter = ROUTE_VISIBILITY_WORKSPACE,
   surfaceId = "",
   accessMode = "auto",
   hasPermissionRequirements = false,
@@ -29,12 +37,11 @@ function useScopeRuntime({
   const accessRequired = resolveAccessModeEnabled(normalizedAccessMode, {
     hasPermissionRequirements
   });
-  const routeContext = useWorkspaceRouteContext();
+  const routeContext = useSurfaceRouteContext();
   const paths = usePaths({
     routeContext
   });
 
-  const workspaceSlugFromRoute = routeContext.workspaceSlugFromRoute;
   const resolvedSurfaceId = computed(() => {
     const explicitSurfaceId = normalizeSurfaceId(surfaceId);
     if (explicitSurfaceId) {
@@ -43,64 +50,85 @@ function useScopeRuntime({
 
     return normalizeSurfaceId(routeContext.currentSurfaceId.value);
   });
-  const workspaceScoped = computed(() =>
-    surfaceRequiresWorkspaceFromPlacementContext(routeContext.placementContext.value, resolvedSurfaceId.value)
+  const scopedRouteParamNames = computed(() =>
+    resolveScopedRouteParamNames(routeContext.placementContext.value, resolvedSurfaceId.value)
   );
-  const hasRouteWorkspaceSlug = computed(() => (workspaceScoped.value ? Boolean(workspaceSlugFromRoute.value) : true));
-  const workspaceRouteError = computed(() => {
-    if (!workspaceScoped.value || hasRouteWorkspaceSlug.value) {
+  const routeScopeParams = computed(() => {
+    const source = paths.routeParams.value;
+    const next = {};
+    for (const paramName of scopedRouteParamNames.value) {
+      const paramValue = toRouteParamValue(source[paramName]);
+      if (paramValue) {
+        next[paramName] = paramValue;
+      }
+    }
+    return Object.freeze(next);
+  });
+  const missingScopedRouteParamNames = computed(() =>
+    scopedRouteParamNames.value.filter((paramName) => !routeScopeParams.value[paramName])
+  );
+  const requiresScopedRouteParams = computed(() => scopedRouteParamNames.value.length > 0);
+  const hasRequiredRouteScope = computed(() => missingScopedRouteParamNames.value.length < 1);
+  const scopeParamValue = computed(() => {
+    const [primaryScopeParamName = ""] = scopedRouteParamNames.value;
+    return primaryScopeParamName ? routeScopeParams.value[primaryScopeParamName] || "" : "";
+  });
+  const routeScopeError = computed(() => {
+    if (!requiresScopedRouteParams.value || hasRequiredRouteScope.value) {
       return "";
     }
 
-    return `Route parameter workspaceSlug is required for surface "${resolvedSurfaceId.value || "<unknown>"}".`;
+    const missingParams = missingScopedRouteParamNames.value.join(", ");
+    return `Route parameters ${missingParams} are required for surface "${resolvedSurfaceId.value || "<unknown>"}".`;
   });
 
   const accessRuntime = useAccess({
-    workspaceSlug: computed(() => (workspaceScoped.value ? workspaceSlugFromRoute.value : "")),
-    enabled: computed(() => accessRequired && hasRouteWorkspaceSlug.value),
+    scopeParamValue,
+    enabled: computed(() => accessRequired && hasRequiredRouteScope.value),
     access: normalizedAccessMode,
     hasPermissionRequirements,
-    mergePlacementContext: accessRequired ? routeContext.mergePlacementContext : null,
     placementSource: String(placementSource || "users-web.scope-runtime")
   });
 
   function resolveApiPath(apiSuffix = "", context = {}) {
-    if (workspaceRouteError.value) {
+    if (routeScopeError.value) {
       return "";
     }
 
     const suffix = resolveApiSuffix(apiSuffix, {
       surfaceId: routeContext.currentSurfaceId.value,
-      workspaceSlug: workspaceSlugFromRoute.value,
+      scopeParamValue: scopeParamValue.value,
       ownershipFilter: normalizedOwnershipFilter,
       ...asPlainObject(context)
     });
 
     return paths.api(suffix, {
       surface: resolvedSurfaceId.value,
-      workspaceSlug: workspaceSlugFromRoute.value
+      params: routeScopeParams.value
     });
   }
 
-  function requireWorkspaceRouteParam(caller = "useScopeRuntime") {
-    if (workspaceRouteError.value) {
-      throw new Error(`${caller}: ${workspaceRouteError.value}`);
+  function requireRouteScope(caller = "useScopeRuntime") {
+    if (routeScopeError.value) {
+      throw new Error(`${caller}: ${routeScopeError.value}`);
     }
   }
 
   return Object.freeze({
     normalizedOwnershipFilter,
-    workspaceScoped: workspaceScoped.value,
+    requiresScopedRouteParams: requiresScopedRouteParams.value,
     resolvedSurfaceId,
     accessMode: normalizedAccessMode,
     accessRequired,
     routeContext,
-    workspaceSlugFromRoute,
-    hasRouteWorkspaceSlug,
-    workspaceRouteError,
+    scopedRouteParamNames,
+    routeScopeParams,
+    scopeParamValue,
+    hasRequiredRouteScope,
+    routeScopeError,
     access: accessRuntime,
     resolveApiPath,
-    requireWorkspaceRouteParam
+    requireRouteScope
   });
 }
 

package/src/client/composables/useSurfaceRouteContext.js

@@ -5,19 +5,13 @@ import {
   resolveSurfaceIdFromPlacementPathname,
   useWebPlacementContext
 } from "@jskit-ai/shell-web/client/placement";
-import { resolveWorkspaceSurfaceIdFromPlacementPathname } from "../lib/workspaceSurfacePaths.js";
 
 function useSurfaceRouteContext() {
   const route = useRoute();
   const { context: placementContext, mergeContext: mergePlacementContext } = useWebPlacementContext();
   const routePath = computed(() => resolveRuntimePathname(route?.path));
 
-  const currentSurfaceId = computed(() => {
-    return (
-      resolveWorkspaceSurfaceIdFromPlacementPathname(placementContext.value, routePath.value) ||
-      resolveSurfaceIdFromPlacementPathname(placementContext.value, routePath.value)
-    );
-  });
+  const currentSurfaceId = computed(() => resolveSurfaceIdFromPlacementPathname(placementContext.value, routePath.value));
 
   return Object.freeze({
     route,

package/src/client/index.js

@@ -1,7 +1,6 @@
 import { UsersWebClientProvider } from "./providers/UsersWebClientProvider.js";
 
 export { UsersWebClientProvider } from "./providers/UsersWebClientProvider.js";
-export { UsersWorkspacesClientProvider } from "./providers/UsersWorkspacesClientProvider.js";
 
 const clientProviders = Object.freeze([UsersWebClientProvider]);
 

package/src/client/lib/bootstrap.js

@@ -1,64 +1,5 @@
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 
-function buildBootstrapApiPath(workspaceSlug = "") {
-  const normalizedWorkspaceSlug = String(workspaceSlug || "").trim();
-  if (!normalizedWorkspaceSlug) {
-    return "/api/bootstrap";
-  }
-
-  const query = new URLSearchParams({
-    workspaceSlug: normalizedWorkspaceSlug
-  });
-  return `/api/bootstrap?${query.toString()}`;
-}
-
-function normalizeWorkspaceEntry(entry) {
-  if (!entry || typeof entry !== "object") {
-    return null;
-  }
-
-  const id = normalizeRecordId(entry.id, { fallback: null });
-  const slug = String(entry.slug || "").trim();
-  if (!id || !slug) {
-    return null;
-  }
-
-  return Object.freeze({
-    id,
-    slug,
-    name: String(entry.name || slug).trim() || slug,
-    color: String(entry.color || "").trim(),
-    secondaryColor: String(entry.secondaryColor || "").trim(),
-    surfaceColor: String(entry.surfaceColor || "").trim(),
-    surfaceVariantColor: String(entry.surfaceVariantColor || "").trim(),
-    avatarUrl: String(entry.avatarUrl || "").trim(),
-    roleSid: String(entry.roleSid || "member").trim().toLowerCase() || "member",
-    isAccessible: entry.isAccessible !== false
-  });
-}
-
-function normalizeWorkspaceList(list) {
-  const source = Array.isArray(list) ? list : [];
-  return source.map(normalizeWorkspaceEntry).filter(Boolean);
-}
-
-function findWorkspaceBySlug(list, workspaceSlug) {
-  const normalizedWorkspaceSlug = String(workspaceSlug || "").trim();
-  if (!normalizedWorkspaceSlug) {
-    return null;
-  }
-
-  const source = Array.isArray(list) ? list : [];
-  for (const entry of source) {
-    const normalizedEntry = normalizeWorkspaceEntry(entry);
-    if (normalizedEntry && normalizedEntry.slug === normalizedWorkspaceSlug) {
-      return normalizedEntry;
-    }
-  }
-
-  return null;
-}
-
 function resolvePlacementUserFromBootstrapPayload(payload = {}, currentUser = null) {
   const source = payload && typeof payload === "object" ? payload : {};
   const session = source.session && typeof source.session === "object" ? source.session : {};
@@ -92,9 +33,5 @@ function resolvePlacementUserFromBootstrapPayload(payload = {}, currentUser = nu
 }
 
 export {
-  buildBootstrapApiPath,
-  normalizeWorkspaceEntry,
-  normalizeWorkspaceList,
-  findWorkspaceBySlug,
   resolvePlacementUserFromBootstrapPayload
 };