vibe64 0.1.21

package/node_modules/@jskit-ai/kernel/shared/support/visibility.js

@@ -0,0 +1,93 @@
+import { normalizeObject, normalizeOpaqueId, normalizeText } from "./normalize.js";
+import { ROUTE_VISIBILITY_PUBLIC, ROUTE_VISIBILITY_USER } from "./policies.js";
+
+const ROUTE_VISIBILITY_LEVELS = Object.freeze([ROUTE_VISIBILITY_PUBLIC, ROUTE_VISIBILITY_USER]);
+const ROUTE_VISIBILITY_LEVEL_SET = new Set(ROUTE_VISIBILITY_LEVELS);
+const ROUTE_VISIBILITY_WORKSPACE = "workspace";
+const ROUTE_VISIBILITY_WORKSPACE_USER = "workspace_user";
+const ROUTE_VISIBILITY_TOKENS = Object.freeze([
+  ROUTE_VISIBILITY_PUBLIC,
+  ROUTE_VISIBILITY_USER,
+  ROUTE_VISIBILITY_WORKSPACE,
+  ROUTE_VISIBILITY_WORKSPACE_USER
+]);
+const ROUTE_VISIBILITY_TOKEN_SET = new Set(ROUTE_VISIBILITY_TOKENS);
+
+function normalizeRouteVisibilityToken(value, { fallback = ROUTE_VISIBILITY_PUBLIC } = {}) {
+  const normalized = normalizeText(value).toLowerCase();
+  if (normalized) {
+    return normalized;
+  }
+
+  const normalizedFallback = normalizeText(fallback).toLowerCase();
+  if (normalizedFallback) {
+    return normalizedFallback;
+  }
+
+  return ROUTE_VISIBILITY_PUBLIC;
+}
+
+function normalizeRouteVisibility(value, { fallback = ROUTE_VISIBILITY_PUBLIC } = {}) {
+  const normalized = normalizeRouteVisibilityToken(value, { fallback });
+  if (ROUTE_VISIBILITY_LEVEL_SET.has(normalized)) {
+    return normalized;
+  }
+
+  const normalizedFallback = normalizeRouteVisibilityToken(fallback, {
+    fallback: ROUTE_VISIBILITY_PUBLIC
+  });
+  if (ROUTE_VISIBILITY_LEVEL_SET.has(normalizedFallback)) {
+    return normalizedFallback;
+  }
+
+  return ROUTE_VISIBILITY_PUBLIC;
+}
+
+function checkRouteVisibility(value, { context = "checkRouteVisibility" } = {}) {
+  const normalized = normalizeRouteVisibilityToken(value);
+  if (ROUTE_VISIBILITY_TOKEN_SET.has(normalized)) {
+    return normalized;
+  }
+
+  throw new TypeError(`${context} must be one of: ${ROUTE_VISIBILITY_TOKENS.join(", ")}.`);
+}
+
+function isWorkspaceRouteVisibility(value = "") {
+  const normalized = checkRouteVisibility(value, {
+    context: "isWorkspaceRouteVisibility visibility"
+  });
+  return normalized === ROUTE_VISIBILITY_WORKSPACE || normalized === ROUTE_VISIBILITY_WORKSPACE_USER;
+}
+
+function normalizeVisibilityScopeKind(value) {
+  const normalized = normalizeText(value).toLowerCase();
+  return normalized || null;
+}
+
+function normalizeVisibilityContext(value = {}) {
+  const source = normalizeObject(value);
+  const normalizedVisibility = normalizeRouteVisibilityToken(source.visibility);
+  const normalizedScopeKind = normalizeVisibilityScopeKind(source.scopeKind);
+
+  return Object.freeze({
+    visibility: normalizedVisibility,
+    scopeKind: normalizedScopeKind,
+    requiresActorScope: source.requiresActorScope === true,
+    scopeOwnerId: normalizeOpaqueId(source.scopeOwnerId),
+    userId: normalizeOpaqueId(source.userId)
+  });
+}
+
+export {
+  ROUTE_VISIBILITY_LEVELS,
+  ROUTE_VISIBILITY_PUBLIC,
+  ROUTE_VISIBILITY_USER,
+  ROUTE_VISIBILITY_WORKSPACE,
+  ROUTE_VISIBILITY_WORKSPACE_USER,
+  ROUTE_VISIBILITY_TOKENS,
+  normalizeRouteVisibilityToken,
+  normalizeRouteVisibility,
+  checkRouteVisibility,
+  isWorkspaceRouteVisibility,
+  normalizeVisibilityContext
+};

package/node_modules/@jskit-ai/kernel/shared/support/visibility.test.js

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  checkRouteVisibility,
+  isWorkspaceRouteVisibility,
+  normalizeRouteVisibilityToken,
+  normalizeRouteVisibility,
+  normalizeVisibilityContext
+} from "./visibility.js";
+
+test("normalizeRouteVisibility keeps kernel core visibility contract", () => {
+  assert.equal(normalizeRouteVisibility("PUBLIC"), "public");
+  assert.equal(normalizeRouteVisibility("user"), "user");
+  assert.equal(normalizeRouteVisibility("workspace"), "public");
+  assert.equal(normalizeRouteVisibility("invalid"), "public");
+  assert.equal(normalizeRouteVisibility("invalid", { fallback: "user" }), "user");
+  assert.equal(normalizeRouteVisibility(""), "public");
+});
+
+test("normalizeRouteVisibilityToken normalizes visibility tokens for module-level resolvers", () => {
+  assert.equal(normalizeRouteVisibilityToken("workspace"), "workspace");
+  assert.equal(normalizeRouteVisibilityToken("WORKSPACE_USER"), "workspace_user");
+  assert.equal(normalizeRouteVisibilityToken(""), "public");
+  assert.equal(normalizeRouteVisibilityToken("", { fallback: "workspace" }), "workspace");
+});
+
+test("checkRouteVisibility accepts workspace visibility tokens", () => {
+  assert.equal(checkRouteVisibility("workspace"), "workspace");
+  assert.equal(checkRouteVisibility("workspace_user"), "workspace_user");
+  assert.throws(() => checkRouteVisibility("invalid"), /must be one of/);
+});
+
+test("isWorkspaceRouteVisibility matches only workspace-scoped tokens", () => {
+  assert.equal(isWorkspaceRouteVisibility("workspace"), true);
+  assert.equal(isWorkspaceRouteVisibility("workspace_user"), true);
+  assert.equal(isWorkspaceRouteVisibility("public"), false);
+});
+
+test("normalizeVisibilityContext normalizes mode and owner identifiers", () => {
+  assert.deepEqual(normalizeVisibilityContext({ visibility: "user", userId: "7" }), {
+    visibility: "user",
+    scopeKind: null,
+    requiresActorScope: false,
+    scopeOwnerId: null,
+    userId: "7"
+  });
+
+  assert.deepEqual(normalizeVisibilityContext({ visibility: "workspace_user", scopeOwnerId: "4", userId: 9 }), {
+    visibility: "workspace_user",
+    scopeKind: null,
+    requiresActorScope: false,
+    scopeOwnerId: "4",
+    userId: "9"
+  });
+
+  assert.deepEqual(normalizeVisibilityContext({ visibility: "workspace", scopeOwnerId: "0" }), {
+    visibility: "workspace",
+    scopeKind: null,
+    requiresActorScope: false,
+    scopeOwnerId: "0",
+    userId: null
+  });
+});

package/node_modules/@jskit-ai/kernel/shared/surface/apiPaths.js

@@ -0,0 +1,157 @@
+import { matchesPathPrefix, normalizePathname } from "./paths.js";
+
+const API_BASE_PATH = "/api";
+const API_PREFIX = "/api";
+const API_PREFIX_SLASH = `${API_PREFIX}/`;
+const API_DOCS_PATH = `${API_PREFIX}/docs`;
+const API_REALTIME_PATH = `${API_PREFIX}/realtime`;
+const VERSIONED_API_PATH_PATTERN = /^\/api\/v[0-9]+(?:$|\/)/;
+
+function normalizeRouteTemplateParams(params = null) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return {};
+  }
+  return params;
+}
+
+function materializeRouteTemplate(routeTemplate = "/", { params = {}, strictParams = true, context = "materializeRouteTemplate" } = {}) {
+  const normalizedTemplate = normalizePathname(routeTemplate);
+  const normalizedParams = normalizeRouteTemplateParams(params);
+  const missingParams = new Set();
+  const outputPath = String(normalizedTemplate || "/").replace(/:([A-Za-z0-9_]+)/g, (_full, rawName) => {
+    const paramName = String(rawName || "").trim();
+    const rawValue = normalizedParams[paramName];
+    const paramValue = String(Array.isArray(rawValue) ? rawValue[0] : rawValue ?? "").trim();
+    if (!paramValue) {
+      missingParams.add(paramName);
+      return `:${paramName}`;
+    }
+    return encodeURIComponent(paramValue);
+  });
+
+  if (strictParams && missingParams.size > 0) {
+    throw new Error(`${context} missing required route params: ${[...missingParams].sort().join(", ")}.`);
+  }
+
+  return outputPath;
+}
+
+function resolveScopedRouteBase(routeBase = "/") {
+  const normalizedRouteBase = normalizePathname(routeBase);
+  const segments = normalizedRouteBase.split("/").filter(Boolean);
+  let lastDynamicIndex = -1;
+
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index];
+    if (segment.startsWith(":") && segment.length > 1) {
+      lastDynamicIndex = index;
+    }
+  }
+
+  if (lastDynamicIndex < 0) {
+    return "/";
+  }
+
+  return `/${segments.slice(0, lastDynamicIndex + 1).join("/")}`;
+}
+
+function resolveScopedApiBasePath({
+  routeBase = "/",
+  relativePath = "/",
+  params = {},
+  strictParams = true
+} = {}) {
+  const scopedRouteBase = resolveScopedRouteBase(routeBase);
+  const materializedScopeBase = materializeRouteTemplate(scopedRouteBase, {
+    params,
+    strictParams,
+    context: "resolveScopedApiBasePath"
+  });
+  const basePath = materializedScopeBase === "/" ? API_BASE_PATH : `${API_BASE_PATH}${materializedScopeBase}`;
+  const normalizedRelativePath = normalizePathname(relativePath || "/");
+
+  if (normalizedRelativePath === "/") {
+    return basePath;
+  }
+
+  return `${basePath}${normalizedRelativePath}`;
+}
+
+function isApiPath(pathname) {
+  return matchesPathPrefix(pathname, API_BASE_PATH);
+}
+
+function isVersionedApiPath(pathname) {
+  return VERSIONED_API_PATH_PATTERN.test(normalizePathname(pathname));
+}
+
+function toVersionedApiPath(pathname) {
+  const normalizedPathname = normalizePathname(pathname);
+  if (!isApiPath(normalizedPathname)) {
+    return normalizedPathname;
+  }
+
+  if (isVersionedApiPath(normalizedPathname)) {
+    return normalizedPathname;
+  }
+
+  if (normalizedPathname === API_BASE_PATH) {
+    return API_PREFIX;
+  }
+
+  return `${API_PREFIX}${normalizedPathname.slice(API_BASE_PATH.length)}`;
+}
+
+function toVersionedApiPrefix(pathnameOrPrefix) {
+  const versionedPath = toVersionedApiPath(pathnameOrPrefix || API_BASE_PATH);
+  if (!isApiPath(versionedPath)) {
+    return normalizePathname(versionedPath);
+  }
+
+  if (versionedPath === API_PREFIX) {
+    return API_PREFIX_SLASH;
+  }
+
+  return `${versionedPath}/`;
+}
+
+function buildVersionedApiPath(suffix) {
+  const rawSuffix = String(suffix || "").trim();
+  if (!rawSuffix || rawSuffix === "/") {
+    return API_PREFIX;
+  }
+
+  const normalizedSuffix = normalizePathname(rawSuffix.startsWith("/") ? rawSuffix : `/${rawSuffix}`);
+  if (isApiPath(normalizedSuffix)) {
+    return toVersionedApiPath(normalizedSuffix);
+  }
+
+  if (normalizedSuffix === "/") {
+    return API_PREFIX;
+  }
+
+  return `${API_PREFIX}${normalizedSuffix}`;
+}
+
+function isVersionedApiPrefixMatch(pathname) {
+  const normalizedPathname = normalizePathname(pathname);
+  return normalizedPathname === API_PREFIX || normalizedPathname.startsWith(API_PREFIX_SLASH);
+}
+
+export {
+  API_BASE_PATH,
+  API_PREFIX,
+  API_PREFIX_SLASH,
+  API_DOCS_PATH,
+  API_REALTIME_PATH,
+  materializeRouteTemplate,
+  normalizePathname,
+  isApiPath,
+  isVersionedApiPath,
+  toVersionedApiPath,
+  toVersionedApiPrefix,
+  buildVersionedApiPath,
+  isVersionedApiPrefixMatch,
+  resolveScopedRouteBase,
+  resolveScopedApiBasePath
+};

package/node_modules/@jskit-ai/kernel/shared/surface/apiPaths.test.js

@@ -0,0 +1,31 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveScopedApiBasePath, resolveScopedRouteBase } from "./apiPaths.js";
+
+test("resolveScopedRouteBase keeps the route prefix through the last dynamic segment", () => {
+  assert.equal(resolveScopedRouteBase("/"), "/");
+  assert.equal(resolveScopedRouteBase("/home"), "/");
+  assert.equal(resolveScopedRouteBase("/w/:workspaceSlug"), "/w/:workspaceSlug");
+  assert.equal(resolveScopedRouteBase("/w/:workspaceSlug/admin"), "/w/:workspaceSlug");
+  assert.equal(resolveScopedRouteBase("/org/:orgId/team/:teamId/admin"), "/org/:orgId/team/:teamId");
+});
+
+test("resolveScopedApiBasePath materializes scoped API paths from route templates", () => {
+  assert.equal(resolveScopedApiBasePath({ routeBase: "/home", relativePath: "/settings" }), "/api/settings");
+  assert.equal(
+    resolveScopedApiBasePath({
+      routeBase: "/w/:workspaceSlug/admin",
+      relativePath: "/members",
+      params: { workspaceSlug: "acme" }
+    }),
+    "/api/w/acme/members"
+  );
+  assert.throws(
+    () =>
+      resolveScopedApiBasePath({
+        routeBase: "/w/:workspaceSlug/admin",
+        relativePath: "/members"
+      }),
+    /missing required route params/
+  );
+});

package/node_modules/@jskit-ai/kernel/shared/surface/escapeRegExp.js

@@ -0,0 +1,5 @@
+function escapeRegExp(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export { escapeRegExp };

package/node_modules/@jskit-ai/kernel/shared/surface/index.js

@@ -0,0 +1,10 @@
+export {
+  normalizeSurfaceId,
+  normalizeSurfacePagesRoot,
+  deriveSurfaceRouteBaseFromPagesRoot
+} from "./registry.js";
+export { createSurfacePathHelpers } from "./paths.js";
+export {
+  resolveScopedRouteBase,
+  resolveScopedApiBasePath
+} from "./apiPaths.js";

package/node_modules/@jskit-ai/kernel/shared/surface/paths.js

@@ -0,0 +1,273 @@
+import { escapeRegExp } from "./escapeRegExp.js";
+
+function normalizePathname(pathname) {
+  const rawValue = String(pathname || "/").trim();
+  if (!rawValue) {
+    return "/";
+  }
+
+  const withoutQuery = rawValue.split("?")[0].split("#")[0];
+  const withLeadingSlash = withoutQuery.startsWith("/") ? withoutQuery : `/${withoutQuery}`;
+  const squashed = withLeadingSlash.replace(/\/{2,}/g, "/");
+  if (squashed === "/") {
+    return "/";
+  }
+
+  return squashed.replace(/\/+$/, "") || "/";
+}
+
+function matchesPathPrefix(pathname, prefix) {
+  const normalizedPathname = normalizePathname(pathname);
+  const normalizedPrefix = normalizePathname(prefix);
+  return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+}
+
+function compileSurfaceRouteMatcher(routeBase) {
+  const normalizedRouteBase = normalizePathname(routeBase);
+  const segments = normalizedRouteBase.split("/").filter(Boolean);
+  if (segments.length < 1) {
+    return Object.freeze({
+      routeBase: "/",
+      segmentCount: 0,
+      staticSegmentCount: 0,
+      test(pathname) {
+        return normalizePathname(pathname).startsWith("/");
+      }
+    });
+  }
+
+  const patternSegments = segments.map((segment) =>
+    segment.startsWith(":") && segment.length > 1 ? "[^/]+" : escapeRegExp(segment)
+  );
+  const pattern = new RegExp(`^/${patternSegments.join("/")}(?:$|/)`);
+  const staticSegmentCount = segments.filter(
+    (segment) => !(segment.startsWith(":") && segment.length > 1)
+  ).length;
+
+  return Object.freeze({
+    routeBase: normalizedRouteBase,
+    segmentCount: segments.length,
+    staticSegmentCount,
+    test(pathname) {
+      return pattern.test(normalizePathname(pathname));
+    }
+  });
+}
+
+function compareSurfaceRouteSpecificity(left, right) {
+  const staticDiff = right.staticSegmentCount - left.staticSegmentCount;
+  if (staticDiff !== 0) {
+    return staticDiff;
+  }
+
+  const segmentDiff = right.segmentCount - left.segmentCount;
+  if (segmentDiff !== 0) {
+    return segmentDiff;
+  }
+
+  const lengthDiff = String(right.routeBase || "").length - String(left.routeBase || "").length;
+  if (lengthDiff !== 0) {
+    return lengthDiff;
+  }
+
+  return String(left.id || "").localeCompare(String(right.id || ""));
+}
+
+function createSurfacePathHelpers(options = {}) {
+  const normalizeSurfaceId = options?.normalizeSurfaceId;
+  const resolveSurfaceRouteBaseFromRegistry = options?.resolveSurfaceRouteBase;
+  const listSurfaceDefinitions = options?.listSurfaceDefinitions;
+
+  if (typeof normalizeSurfaceId !== "function") {
+    throw new Error("createSurfacePathHelpers requires normalizeSurfaceId.");
+  }
+  if (typeof resolveSurfaceRouteBaseFromRegistry !== "function") {
+    throw new Error("createSurfacePathHelpers requires resolveSurfaceRouteBase.");
+  }
+  if (typeof listSurfaceDefinitions !== "function") {
+    throw new Error("createSurfacePathHelpers requires listSurfaceDefinitions.");
+  }
+
+  const defaultSurfaceId = normalizeSurfaceId(options?.defaultSurfaceId);
+  if (!defaultSurfaceId) {
+    throw new Error("createSurfacePathHelpers requires defaultSurfaceId.");
+  }
+
+  const apiBasePath = normalizePathname(options?.apiBasePath || "/api");
+  const routeConfig = options?.routes && typeof options.routes === "object" && !Array.isArray(options.routes) ? options.routes : {};
+
+  function normalizeSurface(surface) {
+    return normalizeSurfaceId(surface);
+  }
+
+  function resolveSurfaceRouteBase(surface) {
+    return normalizePathname(resolveSurfaceRouteBaseFromRegistry(surface));
+  }
+
+  function surfaceDefinitions() {
+    return listSurfaceDefinitions().filter(
+      (surface) => surface && typeof surface === "object" && !Array.isArray(surface)
+    );
+  }
+
+  function routedSurfaceDefinitions() {
+    return surfaceDefinitions()
+      .map((definition) => {
+        const surfaceId = normalizeSurface(definition?.id);
+        if (!surfaceId) {
+          return null;
+        }
+
+        const routeBase = resolveSurfaceRouteBase(surfaceId);
+        const matcher = compileSurfaceRouteMatcher(routeBase);
+        return {
+          id: surfaceId,
+          routeBase,
+          segmentCount: matcher.segmentCount,
+          staticSegmentCount: matcher.staticSegmentCount,
+          matcher
+        };
+      })
+      .filter(Boolean)
+      .sort(compareSurfaceRouteSpecificity);
+  }
+
+  function resolveApiNamespace(pathname) {
+    const normalizedPathname = normalizePathname(pathname);
+    if (!matchesPathPrefix(normalizedPathname, apiBasePath)) {
+      return "";
+    }
+
+    if (normalizedPathname === apiBasePath) {
+      return apiBasePath;
+    }
+
+    const remainder = normalizedPathname.slice(apiBasePath.length);
+    if (!remainder || remainder === "/") {
+      return apiBasePath;
+    }
+
+    const versionMatch = remainder.match(/^\/v[0-9]+(?:$|\/)/);
+    if (!versionMatch) {
+      return apiBasePath;
+    }
+
+    const versionPath = String(versionMatch[0]).replace(/\/$/, "");
+    return normalizePathname(`${apiBasePath}${versionPath}`);
+  }
+
+  function resolveSurfaceFromApiPathname(pathname) {
+    const apiNamespace = resolveApiNamespace(pathname);
+    if (!apiNamespace) {
+      return "";
+    }
+
+    const normalizedPathname = normalizePathname(pathname);
+    const remainder = normalizedPathname.slice(apiNamespace.length) || "/";
+    const apiRelativePath = normalizePathname(remainder.startsWith("/") ? remainder : `/${remainder}`);
+
+    for (const surface of routedSurfaceDefinitions()) {
+      if (surface.matcher.test(apiRelativePath)) {
+        return surface.id;
+      }
+    }
+
+    return defaultSurfaceId;
+  }
+
+  function resolveSurfaceFromPathname(pathname) {
+    const normalizedPathname = normalizePathname(pathname);
+    const apiSurface = resolveSurfaceFromApiPathname(normalizedPathname);
+    if (apiSurface) {
+      return apiSurface;
+    }
+
+    for (const surface of routedSurfaceDefinitions()) {
+      if (surface.matcher.test(normalizedPathname)) {
+        return surface.id;
+      }
+    }
+
+    return defaultSurfaceId;
+  }
+
+  function withSurfaceRouteBase(surface, path) {
+    const normalizedPath = normalizePathname(path);
+    const routeBase = resolveSurfaceRouteBase(surface);
+    if (normalizedPath === "/") {
+      return routeBase || "/";
+    }
+
+    if (routeBase === "/") {
+      return normalizedPath;
+    }
+    return normalizePathname(`${routeBase}${normalizedPath}`);
+  }
+
+  function normalizeOptionalRoutePath(path) {
+    const normalizedPath = String(path || "").trim();
+    if (!normalizedPath) {
+      return "";
+    }
+
+    return normalizePathname(normalizedPath);
+  }
+
+  function createSurfacePaths(surface) {
+    const normalizedSurface = normalizeSurface(surface);
+    const routeBase = resolveSurfaceRouteBase(normalizedSurface);
+
+    const rootPath = routeBase || "/";
+    const namedPaths = {};
+    for (const [routeName, routePath] of Object.entries(routeConfig)) {
+      const normalizedRouteName = String(routeName || "").trim();
+      if (!normalizedRouteName) {
+        continue;
+      }
+      const normalizedRoutePath = normalizeOptionalRoutePath(routePath);
+      if (!normalizedRoutePath) {
+        continue;
+      }
+      namedPaths[normalizedRouteName] = withSurfaceRouteBase(normalizedSurface, normalizedRoutePath);
+    }
+
+    const frozenNamedPaths = Object.freeze({
+      ...namedPaths
+    });
+
+    return {
+      surface: normalizedSurface,
+      routeBase,
+      rootPath,
+      namedPaths: frozenNamedPaths,
+      isNamedPath(routeName, pathname) {
+        const normalizedRouteName = String(routeName || "").trim();
+        if (!normalizedRouteName || !Object.hasOwn(frozenNamedPaths, normalizedRouteName)) {
+          return false;
+        }
+        return normalizePathname(pathname) === frozenNamedPaths[normalizedRouteName];
+      }
+    };
+  }
+
+  function resolveSurfacePaths(pathname) {
+    const browserPathname =
+      typeof window !== "undefined" && window?.location?.pathname ? String(window.location.pathname) : "";
+    const effectivePathname = browserPathname || pathname;
+    return createSurfacePaths(resolveSurfaceFromPathname(effectivePathname));
+  }
+
+  return Object.freeze({
+    normalizePathname,
+    matchesPathPrefix,
+    compileSurfaceRouteMatcher,
+    resolveSurfaceFromApiPathname,
+    resolveSurfaceFromPathname,
+    resolveSurfaceRouteBase,
+    withSurfaceRouteBase,
+    createSurfacePaths,
+    resolveSurfacePaths
+  });
+}
+
+export { createSurfacePathHelpers, normalizePathname, matchesPathPrefix };