vibe64 0.1.21

package/node_modules/@jskit-ai/kernel/client/shellRouting.js

@@ -0,0 +1,321 @@
+import { deriveSurfaceRouteBaseFromPagesRoot } from "../shared/surface/index.js";
+import { filterRoutesBySurface } from "../shared/surface/runtime.js";
+import { isExternalLinkTarget } from "../shared/support/linkPath.js";
+import { AUTH_POLICY_AUTHENTICATED, AUTH_POLICY_PUBLIC } from "../shared/support/policies.js";
+
+const DEFAULT_GUARD_EVALUATOR_KEY = "__JSKIT_WEB_SHELL_GUARD_EVALUATOR__";
+const WEB_ROOT_ALLOW_YES = "yes";
+const WEB_ROOT_ALLOW_NO = "no";
+
+function createFallbackNotFoundRoute(component) {
+  if (!component) {
+    throw new Error("createFallbackNotFoundRoute requires a component.");
+  }
+
+  return Object.freeze({
+    path: "/:pathMatch(.*)*",
+    name: "not-found",
+    component,
+    meta: {
+      jskit: {
+        scope: "global"
+      }
+    }
+  });
+}
+
+function buildSurfaceAwareRoutes({
+  routes = [],
+  surfaceRuntime,
+  surfaceMode,
+  fallbackRoute,
+  notFoundComponent
+} = {}) {
+  const effectiveFallback =
+    fallbackRoute ||
+    (notFoundComponent ? createFallbackNotFoundRoute(notFoundComponent) : null);
+
+  if (!effectiveFallback) {
+    throw new TypeError("buildSurfaceAwareRoutes requires fallbackRoute or notFoundComponent.");
+  }
+  return filterRoutesBySurface([...routes, effectiveFallback], {
+    surfaceRuntime,
+    surfaceMode
+  });
+}
+
+function normalizeGuardPolicy(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase();
+}
+
+function resolveRouteGuardFromMeta(meta) {
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+    return null;
+  }
+
+  if (meta.guard && typeof meta.guard === "object" && !Array.isArray(meta.guard)) {
+    return meta.guard;
+  }
+
+  if (meta.jskit && typeof meta.jskit === "object" && !Array.isArray(meta.jskit)) {
+    const jskitGuard = meta.jskit.guard;
+    if (jskitGuard && typeof jskitGuard === "object" && !Array.isArray(jskitGuard)) {
+      return jskitGuard;
+    }
+  }
+
+  return null;
+}
+
+function resolveRouteGuard(to) {
+  const matched = Array.isArray(to?.matched) ? to.matched : [];
+  for (let index = matched.length - 1; index >= 0; index -= 1) {
+    const routeRecord = matched[index] && typeof matched[index] === "object" ? matched[index] : null;
+    if (!routeRecord) {
+      continue;
+    }
+
+    if (routeRecord.guard && typeof routeRecord.guard === "object" && !Array.isArray(routeRecord.guard)) {
+      return routeRecord.guard;
+    }
+
+    const metaGuard = resolveRouteGuardFromMeta(routeRecord.meta);
+    if (metaGuard) {
+      return metaGuard;
+    }
+  }
+
+  return null;
+}
+
+function resolveSearchFromFullPath(fullPath) {
+  const rawFullPath = String(fullPath || "").trim();
+  const queryStart = rawFullPath.indexOf("?");
+  if (queryStart < 0) {
+    return "";
+  }
+
+  const hashStart = rawFullPath.indexOf("#", queryStart);
+  return hashStart < 0 ? rawFullPath.slice(queryStart) : rawFullPath.slice(queryStart, hashStart);
+}
+
+function resolveSurfaceDefinition(surfaceDefinitions, surfaceId) {
+  const normalizedSurfaceId = String(surfaceId || "")
+    .trim()
+    .toLowerCase();
+  if (!normalizedSurfaceId) {
+    return null;
+  }
+  const definition = surfaceDefinitions[normalizedSurfaceId];
+  if (!definition || typeof definition !== "object") {
+    return null;
+  }
+  return definition;
+}
+
+function normalizeWebRootAllowed(value) {
+  const normalizedValue = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (normalizedValue === WEB_ROOT_ALLOW_YES || normalizedValue === WEB_ROOT_ALLOW_NO) {
+    return normalizedValue;
+  }
+  return WEB_ROOT_ALLOW_YES;
+}
+
+function resolveDefaultSurfaceRootPath({ surfaceDefinitions, defaultSurfaceId }) {
+  const defaultSurface = resolveSurfaceDefinition(surfaceDefinitions, defaultSurfaceId);
+  return String(
+    defaultSurface?.routeBase || deriveSurfaceRouteBaseFromPagesRoot(defaultSurface?.pagesRoot || "")
+  ).trim() || "/";
+}
+
+function resolveSurfaceRequiresAuth({ pathname, surfaceRuntime, surfaceDefinitions }) {
+  const normalizedPathname = String(pathname || "/").trim() || "/";
+  const surfaceId = surfaceRuntime.resolveSurfaceFromPathname(normalizedPathname);
+  const surfaceDefinition = resolveSurfaceDefinition(surfaceDefinitions, surfaceId);
+  return Boolean(surfaceDefinition?.requiresAuth);
+}
+
+function resolveEffectiveRouteGuard({
+  to,
+  surfaceRuntime,
+  surfaceDefinitions,
+  authenticatedPolicy = AUTH_POLICY_AUTHENTICATED,
+  publicPolicy = AUTH_POLICY_PUBLIC
+}) {
+  const routeGuard = resolveRouteGuard(to);
+  const routePolicy = normalizeGuardPolicy(routeGuard?.policy);
+  if (routePolicy) {
+    return {
+      policy: routePolicy
+    };
+  }
+
+  if (
+    resolveSurfaceRequiresAuth({
+      pathname: to?.path || "/",
+      surfaceRuntime,
+      surfaceDefinitions
+    })
+  ) {
+    return {
+      policy: authenticatedPolicy
+    };
+  }
+
+  return {
+    policy: publicPolicy
+  };
+}
+
+function resolveGuardEvaluator(guardEvaluatorKey) {
+  if (typeof globalThis !== "object" || !globalThis) {
+    return null;
+  }
+
+  const evaluator = globalThis[guardEvaluatorKey];
+  if (typeof evaluator !== "function") {
+    return null;
+  }
+  return evaluator;
+}
+
+function normalizeGuardOutcome(outcome) {
+  if (outcome === false) {
+    return {
+      allow: false,
+      redirectTo: "",
+      reason: ""
+    };
+  }
+
+  if (outcome == null || outcome === true || typeof outcome !== "object" || Array.isArray(outcome)) {
+    return {
+      allow: true,
+      redirectTo: "",
+      reason: ""
+    };
+  }
+
+  return {
+    allow: outcome.allow !== false,
+    redirectTo: String(outcome.redirectTo || "").trim(),
+    reason: String(outcome.reason || "").trim()
+  };
+}
+
+function evaluateShellGuard({ guard, to, guardEvaluatorKey }) {
+  const evaluator = resolveGuardEvaluator(guardEvaluatorKey);
+  if (!evaluator) {
+    return {
+      allow: true,
+      redirectTo: "",
+      reason: ""
+    };
+  }
+
+  const pathname = String(to?.path || "/").trim() || "/";
+  const search = resolveSearchFromFullPath(to?.fullPath || "");
+
+  try {
+    return normalizeGuardOutcome(
+      evaluator({
+        guard,
+        phase: "route",
+        context: {
+          to,
+          location: {
+            pathname,
+            search
+          }
+        }
+      })
+    );
+  } catch {
+    return {
+      allow: false,
+      redirectTo: "",
+      reason: "guard-evaluator-error"
+    };
+  }
+}
+
+function createShellBeforeEachGuard({
+  surfaceRuntime,
+  surfaceDefinitions,
+  defaultSurfaceId,
+  webRootAllowed = WEB_ROOT_ALLOW_YES,
+  guardEvaluatorKey = DEFAULT_GUARD_EVALUATOR_KEY,
+  authenticatedPolicy = AUTH_POLICY_AUTHENTICATED,
+  publicPolicy = AUTH_POLICY_PUBLIC
+} = {}) {
+  if (!surfaceRuntime || typeof surfaceRuntime.resolveSurfaceFromPathname !== "function") {
+    throw new TypeError("createShellBeforeEachGuard requires surfaceRuntime.resolveSurfaceFromPathname().");
+  }
+  if (!surfaceDefinitions || typeof surfaceDefinitions !== "object" || Array.isArray(surfaceDefinitions)) {
+    throw new TypeError("createShellBeforeEachGuard requires a surfaceDefinitions object.");
+  }
+
+  return (to) => {
+    const normalizedWebRootAllowed = normalizeWebRootAllowed(webRootAllowed);
+    const defaultSurfaceRootPath = resolveDefaultSurfaceRootPath({
+      surfaceDefinitions,
+      defaultSurfaceId
+    });
+    if (
+      normalizedWebRootAllowed === WEB_ROOT_ALLOW_NO &&
+      String(to?.path || "/").trim() === "/" &&
+      defaultSurfaceRootPath !== "/"
+    ) {
+      const search = resolveSearchFromFullPath(to?.fullPath || "");
+      const hash = String(to?.hash || "").trim();
+      return `${defaultSurfaceRootPath}${search}${hash}`;
+    }
+
+    const guard = resolveEffectiveRouteGuard({
+      to,
+      surfaceRuntime,
+      surfaceDefinitions,
+      authenticatedPolicy,
+      publicPolicy
+    });
+    if (guard.policy !== authenticatedPolicy) {
+      return true;
+    }
+
+    const outcome = evaluateShellGuard({
+      guard,
+      to,
+      guardEvaluatorKey
+    });
+    if (outcome.allow) {
+      return true;
+    }
+
+    if (outcome.redirectTo) {
+      if (isExternalLinkTarget(outcome.redirectTo)) {
+        if (typeof window === "object" && window?.location && typeof window.location.assign === "function") {
+          window.location.assign(outcome.redirectTo);
+        }
+        return false;
+      }
+      return outcome.redirectTo;
+    }
+
+    return false;
+  };
+}
+
+export {
+  AUTH_POLICY_AUTHENTICATED,
+  AUTH_POLICY_PUBLIC,
+  WEB_ROOT_ALLOW_YES,
+  WEB_ROOT_ALLOW_NO,
+  DEFAULT_GUARD_EVALUATOR_KEY,
+  createFallbackNotFoundRoute,
+  buildSurfaceAwareRoutes,
+  createShellBeforeEachGuard
+};

package/node_modules/@jskit-ai/kernel/client/shellRouting.test.js

@@ -0,0 +1,113 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createSurfaceRuntime } from "../shared/surface/runtime.js";
+import { buildSurfaceAwareRoutes } from "./shellRouting.js";
+
+test("buildSurfaceAwareRoutes keeps declared route paths and filters by surface mode", () => {
+  const surfaceRuntime = createSurfaceRuntime({
+    defaultSurfaceId: "app",
+    surfaces: {
+      app: { id: "app", pagesRoot: "app", enabled: true, requiresWorkspace: false },
+      coffie: { id: "coffie", pagesRoot: "coffie", enabled: true, requiresWorkspace: true },
+      console: { id: "console", pagesRoot: "console", enabled: true, requiresWorkspace: false }
+    }
+  });
+
+  const routes = buildSurfaceAwareRoutes({
+    routes: [
+      {
+        path: "/app/home",
+        name: "app-home",
+        component: {}
+      },
+      {
+        path: "/coffie",
+        name: "coffie-home",
+        component: {}
+      },
+      {
+        path: "/coffie/members",
+        name: "coffie-members",
+        component: {}
+      },
+      {
+        path: "/coffie/workspaces",
+        name: "coffie-workspaces",
+        component: {}
+      },
+      {
+        path: "/console/settings",
+        name: "console-settings",
+        component: {}
+      },
+      {
+        path: "/auth/login",
+        name: "auth-login",
+        scope: "global",
+        component: {}
+      },
+      {
+        path: "/",
+        name: "root-global",
+        component: {},
+        meta: {
+          jskit: {
+            scope: "global"
+          }
+        }
+      }
+    ],
+    surfaceRuntime,
+    surfaceMode: "all",
+    notFoundComponent: {}
+  });
+
+  const routePaths = routes.map((route) => route.path);
+  assert.equal(routePaths.includes("/coffie"), true);
+  assert.equal(routePaths.includes("/coffie/members"), true);
+  assert.equal(routePaths.includes("/coffie/workspaces"), true);
+  assert.equal(routePaths.includes("/app/home"), true);
+  assert.equal(routePaths.includes("/console/settings"), true);
+  assert.equal(routePaths.includes("/auth/login"), true);
+  assert.equal(routePaths.includes("/"), true);
+});
+
+test("buildSurfaceAwareRoutes preserves parent path when nested descendants are global", () => {
+  const surfaceRuntime = createSurfaceRuntime({
+    defaultSurfaceId: "app",
+    surfaces: {
+      app: { id: "app", pagesRoot: "w/[workspaceSlug]", enabled: true, requiresWorkspace: true },
+      admin: { id: "admin", pagesRoot: "w/[workspaceSlug]/admin", enabled: true, requiresWorkspace: true }
+    }
+  });
+
+  const routes = buildSurfaceAwareRoutes({
+    routes: [
+      {
+        path: "/account",
+        children: [
+          {
+            path: "settings",
+            children: [
+              {
+                path: "",
+                component: {},
+                meta: {
+                  jskit: {
+                    scope: "global"
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ],
+    surfaceRuntime,
+    surfaceMode: "all",
+    notFoundComponent: {}
+  });
+
+  const routePaths = routes.map((route) => route.path);
+  assert.equal(routePaths.includes("/account"), true);
+});

package/node_modules/@jskit-ai/kernel/client/vite/clientBootstrapPlugin.js

@@ -0,0 +1,260 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { loadInstalledPackageDescriptor } from "../../internal/node/installedPackageDescriptor.js";
+import { normalizeObject } from "../../shared/support/normalize.js";
+import { sortStrings } from "../../shared/support/sorting.js";
+import {
+  normalizeDescriptorClientProviders,
+  normalizeDescriptorClientOptimizeIncludeSpecifiers,
+  normalizeDescriptorUiRoutes,
+  normalizeClientDescriptorSections
+} from "../descriptorSections.js";
+
+const CLIENT_BOOTSTRAP_VIRTUAL_ID = "virtual:jskit-client-bootstrap";
+const CLIENT_BOOTSTRAP_RESOLVED_ID = `\0${CLIENT_BOOTSTRAP_VIRTUAL_ID}`;
+const CLIENT_RUNTIME_DEDUPE_SPECIFIERS = Object.freeze([
+  "@tanstack/vue-query",
+  "pinia",
+  "vue",
+  "vue-router",
+  "vuetify"
+]);
+
+function isLocalScopePackageId(value) {
+  return String(value || "").trim().startsWith("@local/");
+}
+
+async function readJsonFile(filePath, fallback) {
+  try {
+    const source = await readFile(filePath, "utf8");
+    return JSON.parse(source);
+  } catch {
+    return fallback;
+  }
+}
+
+function hasClientExport(packageJson) {
+  const exportsMap = normalizeObject(packageJson?.exports);
+  return Boolean(exportsMap["./client"]);
+}
+
+async function resolveInstalledClientModules({ appRoot, lockPath }) {
+  const absoluteLockPath = path.resolve(appRoot, lockPath);
+  const lockPayload = await readJsonFile(absoluteLockPath, {});
+  const installedPackages = normalizeObject(lockPayload.installedPackages);
+  const packageIds = sortStrings(Object.keys(installedPackages));
+
+  const modules = [];
+  for (const packageId of packageIds) {
+    const installedPackageState = normalizeObject(installedPackages[packageId]);
+    const packageJsonPath = path.resolve(appRoot, "node_modules", ...packageId.split("/"), "package.json");
+    const packageJson = await readJsonFile(packageJsonPath, {});
+    if (!hasClientExport(packageJson)) {
+      continue;
+    }
+
+    const descriptorRecord = await loadInstalledPackageDescriptor({
+      appRoot,
+      packageId,
+      installedPackageState,
+      required: false
+    });
+    const descriptorSections = normalizeClientDescriptorSections(descriptorRecord.descriptor);
+
+    modules.push(
+      Object.freeze({
+        packageId,
+        sourceType: String(installedPackageState?.source?.type || "").trim().toLowerCase(),
+        descriptorUiRoutes: descriptorSections.descriptorUiRoutes,
+        descriptorClientProviders: descriptorSections.descriptorClientProviders,
+        descriptorClientOptimizeIncludeSpecifiers: descriptorSections.descriptorClientOptimizeIncludeSpecifiers
+      })
+    );
+  }
+
+  return Object.freeze(modules);
+}
+
+async function resolveInstalledClientPackageIds(options) {
+  const modules = await resolveInstalledClientModules(options);
+  return Object.freeze(modules.map((entry) => entry.packageId));
+}
+
+async function resolveLocalScopePackageIds({ appRoot, lockPath }) {
+  const absoluteLockPath = path.resolve(appRoot, lockPath);
+  const lockPayload = await readJsonFile(absoluteLockPath, {});
+  const installedPackages = normalizeObject(lockPayload.installedPackages);
+  const localScopeFromLock = Object.keys(installedPackages).filter((packageId) => isLocalScopePackageId(packageId));
+
+  const appPackageJson = await readJsonFile(path.resolve(appRoot, "package.json"), {});
+  const localScopeFromPackageJson = Object.keys({
+    ...normalizeObject(appPackageJson.dependencies),
+    ...normalizeObject(appPackageJson.devDependencies),
+    ...normalizeObject(appPackageJson.optionalDependencies),
+    ...normalizeObject(appPackageJson.peerDependencies)
+  }).filter((packageId) => isLocalScopePackageId(packageId));
+
+  return Object.freeze(sortStrings([...localScopeFromLock, ...localScopeFromPackageJson]));
+}
+
+function normalizeClientModuleDescriptors(value) {
+  const items = Array.isArray(value) ? value : [];
+  const descriptors = [];
+
+  for (const item of items) {
+    const record = normalizeObject(item);
+    const packageId = String(record.packageId || "").trim();
+    if (!packageId) {
+      continue;
+    }
+    const sourceType = String(record.sourceType || "").trim().toLowerCase();
+    descriptors.push({
+      packageId,
+      sourceType,
+      descriptorUiRoutes: normalizeDescriptorUiRoutes(record.descriptorUiRoutes),
+      descriptorClientProviders: normalizeDescriptorClientProviders(record.descriptorClientProviders),
+      descriptorClientOptimizeIncludeSpecifiers: normalizeDescriptorClientOptimizeIncludeSpecifiers(
+        record.descriptorClientOptimizeIncludeSpecifiers
+      )
+    });
+  }
+
+  return Object.freeze(
+    descriptors.sort((left, right) => left.packageId.localeCompare(right.packageId))
+  );
+}
+
+function createVirtualModuleSource(clientModules = []) {
+  const moduleDescriptors = normalizeClientModuleDescriptors(clientModules);
+  const importLines = moduleDescriptors.map(
+    (entry, index) => `import * as clientModule${index} from ${JSON.stringify(`${entry.packageId}/client`)};`
+  );
+  const moduleEntries = moduleDescriptors.map(
+    (entry, index) =>
+      `  { packageId: ${JSON.stringify(entry.packageId)}, module: clientModule${index}, descriptorUiRoutes: ${JSON.stringify(entry.descriptorUiRoutes)}, descriptorClientProviders: ${JSON.stringify(entry.descriptorClientProviders)} }`
+  );
+
+  const entriesSource = moduleEntries.length > 0 ? moduleEntries.join(",\n") : "";
+
+  return `${importLines.join("\n")}${importLines.length > 0 ? "\n\n" : ""}import { bootClientModules } from "@jskit-ai/kernel/client/moduleBootstrap";
+
+const installedClientModules = Object.freeze([
+${entriesSource}
+]);
+
+async function bootInstalledClientModules(context = {}) {
+  return bootClientModules({
+    ...context,
+    clientModules: installedClientModules
+  });
+}
+
+export { installedClientModules, bootInstalledClientModules };
+`;
+}
+
+// Vite-only: this Set-based source-type filter exists solely to drive optimizeDeps include/exclude decisions.
+function resolveClientOptimizeExcludeSpecifiers(clientModules = []) {
+  const moduleDescriptors = normalizeClientModuleDescriptors(clientModules);
+  const localSourceTypes = new Set(["local-package", "app-local-package"]);
+  return sortStrings(
+    moduleDescriptors
+      .filter((entry) => localSourceTypes.has(entry.sourceType))
+      .flatMap((entry) => [entry.packageId, `${entry.packageId}/shared`, `${entry.packageId}/client`])
+  );
+}
+
+function resolveClientOptimizeIncludeSpecifiers(clientModules = []) {
+  const moduleDescriptors = normalizeClientModuleDescriptors(clientModules);
+  const localSourceTypes = new Set(["local-package", "app-local-package"]);
+  return sortStrings(
+    [
+      ...moduleDescriptors
+      .filter((entry) => !localSourceTypes.has(entry.sourceType))
+      .map((entry) => `${entry.packageId}/client`),
+      ...moduleDescriptors.flatMap((entry) => entry.descriptorClientOptimizeIncludeSpecifiers || [])
+    ]
+  );
+}
+
+function resolveLocalScopeOptimizeExcludeSpecifiers(localScopePackageIds = []) {
+  return sortStrings(
+    localScopePackageIds.flatMap((packageId) => [packageId, `${packageId}/shared`, `${packageId}/client`])
+  );
+}
+
+function resolveClientRuntimeDedupeSpecifiers(userResolveConfig = {}) {
+  const resolveConfig = normalizeObject(userResolveConfig);
+  const userDedupe = sortStrings(resolveConfig.dedupe);
+  return sortStrings([...userDedupe, ...CLIENT_RUNTIME_DEDUPE_SPECIFIERS]);
+}
+
+function createJskitClientBootstrapPlugin({ lockPath = ".jskit/lock.json" } = {}) {
+  return {
+    name: "jskit-client-bootstrap",
+    async config(userConfig = {}) {
+      const appRoot = process.cwd();
+      const clientModules = await resolveInstalledClientModules({
+        appRoot,
+        lockPath
+      });
+      const localScopePackageIds = await resolveLocalScopePackageIds({
+        appRoot,
+        lockPath
+      });
+      const clientExcludeSpecifiers = resolveClientOptimizeExcludeSpecifiers(clientModules);
+      const localScopeExcludeSpecifiers = resolveLocalScopeOptimizeExcludeSpecifiers(localScopePackageIds);
+      const clientIncludeSpecifiers = resolveClientOptimizeIncludeSpecifiers(clientModules);
+      const userOptimizeDeps = normalizeObject(userConfig.optimizeDeps);
+      const userExclude = sortStrings(userOptimizeDeps.exclude);
+      const userInclude = sortStrings(userOptimizeDeps.include);
+      const exclude = sortStrings([...userExclude, ...clientExcludeSpecifiers, ...localScopeExcludeSpecifiers]);
+      const include = sortStrings([...userInclude, ...clientIncludeSpecifiers]);
+      const userResolve = normalizeObject(userConfig.resolve);
+      const dedupe = resolveClientRuntimeDedupeSpecifiers(userResolve);
+
+      return {
+        optimizeDeps: {
+          ...userOptimizeDeps,
+          include,
+          exclude
+        },
+        resolve: {
+          ...userResolve,
+          dedupe
+        }
+      };
+    },
+    resolveId(source) {
+      if (source === CLIENT_BOOTSTRAP_VIRTUAL_ID) {
+        return CLIENT_BOOTSTRAP_RESOLVED_ID;
+      }
+      return null;
+    },
+    async load(id) {
+      if (id !== CLIENT_BOOTSTRAP_RESOLVED_ID) {
+        return null;
+      }
+
+      const clientModules = await resolveInstalledClientModules({
+        appRoot: process.cwd(),
+        lockPath
+      });
+
+      return createVirtualModuleSource(clientModules);
+    }
+  };
+}
+
+export {
+  CLIENT_BOOTSTRAP_VIRTUAL_ID,
+  CLIENT_BOOTSTRAP_RESOLVED_ID,
+  createVirtualModuleSource,
+  resolveClientOptimizeIncludeSpecifiers,
+  resolveClientOptimizeExcludeSpecifiers,
+  resolveLocalScopeOptimizeExcludeSpecifiers,
+  resolveInstalledClientPackageIds,
+  resolveLocalScopePackageIds,
+  resolveInstalledClientModules,
+  createJskitClientBootstrapPlugin
+};