@servlyadmin/runtime-core 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,3 +1,12 @@
+import {
+  buildRegistryFromBundle,
+  collectAllDependencies,
+  createRegistry,
+  detectCircularDependencies,
+  extractDependencies,
+  extractDependenciesFromCode
+} from "./chunk-CIUQK4GA.js";
+
 // src/bindings.ts
 var BINDING_SOURCES = [
   "props",
@@ -294,17 +303,39 @@ function applyStyles(element, styles) {
     }
   }
 }
+var CANVAS_ONLY_STYLES = /* @__PURE__ */ new Set([
+  "transform",
+  "--translate-x",
+  "--translate-y",
+  "--width",
+  "--height",
+  "z-index",
+  "zIndex"
+]);
+function filterCanvasStyles(style) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(style)) {
+    if (CANVAS_ONLY_STYLES.has(key)) {
+      continue;
+    }
+    if (key === "transform" && typeof value === "string" && value.includes("translate(")) {
+      continue;
+    }
+    filtered[key] = value;
+  }
+  return filtered;
+}
 function buildElementStyles(element, context) {
   const config = element.configuration || {};
   const combined = {};
   if (element.style) {
-    Object.assign(combined, element.style);
+    Object.assign(combined, filterCanvasStyles(element.style));
   }
   if (config.style) {
-    Object.assign(combined, config.style);
+    Object.assign(combined, filterCanvasStyles(config.style));
   }
   if (config.cssVariables) {
-    Object.assign(combined, config.cssVariables);
+    Object.assign(combined, filterCanvasStyles(config.cssVariables));
   }
   return processStyles(combined, context);
 }
@@ -527,18 +558,84 @@ function createElement(element, context, eventHandlers) {
   attachEventHandlers(domElement, element.i, eventHandlers, elementState);
   return elementState;
 }
-function renderElement(element, tree, context, eventHandlers, elementStates) {
+var globalRenderingStack = /* @__PURE__ */ new Set();
+function renderComponentRef(element, container, context, state) {
+  const config = element.configuration;
+  if (!config?.componentViewRef) return void 0;
+  const refId = config.componentViewRef;
+  const refVersion = config.componentViewVersion;
+  if (globalRenderingStack.has(refId)) {
+    console.warn(`Circular dependency detected: ${refId} is already being rendered`);
+    const placeholder = document.createElement("div");
+    placeholder.setAttribute("data-servly-circular", refId);
+    placeholder.textContent = `[Circular: ${refId}]`;
+    container.appendChild(placeholder);
+    return void 0;
+  }
+  let component;
+  if (state.componentRegistry) {
+    component = state.componentRegistry.get(refId, refVersion);
+  }
+  if (!component) {
+    const placeholder = document.createElement("div");
+    placeholder.setAttribute("data-servly-loading", refId);
+    placeholder.className = "servly-loading";
+    container.appendChild(placeholder);
+    if (state.onDependencyNeeded) {
+      state.onDependencyNeeded(refId, refVersion).then((loaded) => {
+        if (loaded && state.componentRegistry) {
+          state.componentRegistry.set(refId, refVersion || "latest", loaded);
+          container.innerHTML = "";
+          renderComponentRef(element, container, context, state);
+        }
+      }).catch((err) => {
+        console.error(`Failed to load dependency ${refId}:`, err);
+        placeholder.textContent = `[Failed to load: ${refId}]`;
+        placeholder.className = "servly-error";
+      });
+    }
+    return void 0;
+  }
+  const refProps = config.componentViewProps ? resolveTemplatesDeep(config.componentViewProps, context) : {};
+  globalRenderingStack.add(refId);
+  const refContext = {
+    props: refProps,
+    state: context.state,
+    context: context.context
+  };
+  try {
+    const result = render({
+      container,
+      elements: component.layout,
+      context: refContext,
+      componentRegistry: state.componentRegistry,
+      onDependencyNeeded: state.onDependencyNeeded
+    });
+    return result;
+  } finally {
+    globalRenderingStack.delete(refId);
+  }
+}
+function renderElement(element, tree, context, eventHandlers, elementStates, state) {
   const elementState = createElement(element, context, eventHandlers);
   elementStates.set(element.i, elementState);
+  const config = element.configuration;
+  if (config?.componentViewRef) {
+    const nestedResult = renderComponentRef(element, elementState.domElement, context, state);
+    if (nestedResult) {
+      elementState.nestedRender = nestedResult;
+    }
+    return elementState.domElement;
+  }
   const children = tree.get(element.i) || [];
   for (const child of children) {
-    const childElement = renderElement(child, tree, context, eventHandlers, elementStates);
+    const childElement = renderElement(child, tree, context, eventHandlers, elementStates, state);
     elementState.domElement.appendChild(childElement);
   }
   return elementState.domElement;
 }
 function render(options) {
-  const { container, elements, context, eventHandlers } = options;
+  const { container, elements, context, eventHandlers, componentRegistry, onDependencyNeeded } = options;
   const tree = buildTree(elements);
   const rootElements = elements.filter((el) => !el.parent || el.parent === null);
   const state = {
@@ -547,7 +644,10 @@ function render(options) {
     context,
     eventHandlers,
     elementStates: /* @__PURE__ */ new Map(),
-    rootElement: null
+    rootElement: null,
+    componentRegistry,
+    onDependencyNeeded,
+    renderingStack: /* @__PURE__ */ new Set()
   };
   container.innerHTML = "";
   if (rootElements.length === 0) {
@@ -563,14 +663,15 @@ function render(options) {
       tree,
       context,
       eventHandlers,
-      state.elementStates
+      state.elementStates,
+      state
     );
     container.appendChild(state.rootElement);
   } else {
     const wrapper = document.createElement("div");
     wrapper.setAttribute("data-servly-wrapper", "true");
     for (const root of rootElements) {
-      const rootElement = renderElement(root, tree, context, eventHandlers, state.elementStates);
+      const rootElement = renderElement(root, tree, context, eventHandlers, state.elementStates, state);
       wrapper.appendChild(rootElement);
     }
     state.rootElement = wrapper;
@@ -608,6 +709,9 @@ function update(state, newContext) {
 function destroy(state) {
   for (const elementState of state.elementStates.values()) {
     detachEventHandlers(elementState);
+    if (elementState.nestedRender) {
+      elementState.nestedRender.destroy();
+    }
   }
   state.elementStates.clear();
   if (state.rootElement && state.rootElement.parentNode) {
@@ -615,6 +719,66 @@ function destroy(state) {
   }
   state.rootElement = null;
 }
+function renderDynamicList(options) {
+  const {
+    targetContainer,
+    blueprint,
+    blueprintVersion,
+    data,
+    renderType = "renderInto",
+    itemKey = "item",
+    indexKey = "index",
+    componentRegistry,
+    context = { props: {} }
+  } = options;
+  let container;
+  if (typeof targetContainer === "string") {
+    container = document.querySelector(targetContainer);
+  } else {
+    container = targetContainer;
+  }
+  if (!container) {
+    console.error(`renderDynamicList: Container not found: ${targetContainer}`);
+    return [];
+  }
+  const blueprintComponent = componentRegistry.get(blueprint, blueprintVersion);
+  if (!blueprintComponent) {
+    console.error(`renderDynamicList: Blueprint not found: ${blueprint}`);
+    return [];
+  }
+  if (renderType === "renderInto") {
+    container.innerHTML = "";
+  }
+  const results = [];
+  const fragment = document.createDocumentFragment();
+  data.forEach((item, index) => {
+    const itemContainer = document.createElement("div");
+    itemContainer.setAttribute("data-servly-list-item", String(index));
+    const itemContext = {
+      props: {
+        ...context.props,
+        [itemKey]: item,
+        [indexKey]: index
+      },
+      state: context.state,
+      context: context.context
+    };
+    const result = render({
+      container: itemContainer,
+      elements: blueprintComponent.layout,
+      context: itemContext,
+      componentRegistry
+    });
+    results.push(result);
+    fragment.appendChild(itemContainer);
+  });
+  if (renderType === "prepend") {
+    container.insertBefore(fragment, container.firstChild);
+  } else {
+    container.appendChild(fragment);
+  }
+  return results;
+}
 
 // src/cache.ts
 var DEFAULT_CACHE_CONFIG = {
@@ -860,118 +1024,6 @@ function invalidateCache(id, version, config = DEFAULT_CACHE_CONFIG) {
   }
 }
 
-// src/version.ts
-function parseVersion(version) {
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) return null;
-  return {
-    major: parseInt(match[1], 10),
-    minor: parseInt(match[2], 10),
-    patch: parseInt(match[3], 10)
-  };
-}
-function compareVersions(a, b) {
-  const parsedA = parseVersion(a);
-  const parsedB = parseVersion(b);
-  if (!parsedA || !parsedB) return 0;
-  if (parsedA.major !== parsedB.major) {
-    return parsedA.major > parsedB.major ? 1 : -1;
-  }
-  if (parsedA.minor !== parsedB.minor) {
-    return parsedA.minor > parsedB.minor ? 1 : -1;
-  }
-  if (parsedA.patch !== parsedB.patch) {
-    return parsedA.patch > parsedB.patch ? 1 : -1;
-  }
-  return 0;
-}
-function satisfiesVersion(version, specifier) {
-  if (specifier === "latest" || specifier === "*") {
-    return true;
-  }
-  const parsed = parseVersion(version);
-  if (!parsed) return false;
-  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
-    return version === specifier;
-  }
-  if (specifier.startsWith("^")) {
-    const specParsed = parseVersion(specifier.slice(1));
-    if (!specParsed) return false;
-    if (parsed.major !== specParsed.major) return false;
-    if (parsed.major === 0) {
-      return parsed.minor === specParsed.minor && parsed.patch >= specParsed.patch;
-    }
-    return compareVersions(version, specifier.slice(1)) >= 0;
-  }
-  if (specifier.startsWith("~")) {
-    const specParsed = parseVersion(specifier.slice(1));
-    if (!specParsed) return false;
-    return parsed.major === specParsed.major && parsed.minor === specParsed.minor && parsed.patch >= specParsed.patch;
-  }
-  if (specifier.startsWith(">=")) {
-    return compareVersions(version, specifier.slice(2)) >= 0;
-  }
-  if (specifier.startsWith(">")) {
-    return compareVersions(version, specifier.slice(1)) > 0;
-  }
-  if (specifier.startsWith("<=")) {
-    return compareVersions(version, specifier.slice(2)) <= 0;
-  }
-  if (specifier.startsWith("<")) {
-    return compareVersions(version, specifier.slice(1)) < 0;
-  }
-  return false;
-}
-function resolveVersion(versions, specifier = "latest") {
-  if (versions.length === 0) {
-    return null;
-  }
-  const sorted = [...versions].sort((a, b) => compareVersions(b, a));
-  if (specifier === "latest" || specifier === "*") {
-    return sorted[0];
-  }
-  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
-    return versions.includes(specifier) ? specifier : null;
-  }
-  for (const version of sorted) {
-    if (satisfiesVersion(version, specifier)) {
-      return version;
-    }
-  }
-  return null;
-}
-function bumpVersion(currentVersion, bumpType) {
-  const parsed = parseVersion(currentVersion);
-  if (!parsed) return "1.0.0";
-  switch (bumpType) {
-    case "major":
-      return `${parsed.major + 1}.0.0`;
-    case "minor":
-      return `${parsed.major}.${parsed.minor + 1}.0`;
-    case "patch":
-      return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
-    default:
-      return currentVersion;
-  }
-}
-function isValidSpecifier(specifier) {
-  if (specifier === "latest" || specifier === "*") {
-    return true;
-  }
-  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
-    return true;
-  }
-  if (/^[\^~><]=?\d+\.\d+\.\d+$/.test(specifier)) {
-    return true;
-  }
-  return false;
-}
-function formatVersion(version) {
-  const parsed = parseVersion(version);
-  if (!parsed) return version;
-  return `v${parsed.major}.${parsed.minor}.${parsed.patch}`;
-}
-
 // src/fetcher.ts
 var DEFAULT_RETRY_CONFIG = {
   maxRetries: 3,
@@ -979,7 +1031,7 @@ var DEFAULT_RETRY_CONFIG = {
   maxDelay: 1e4,
   backoffMultiplier: 2
 };
-var registryBaseUrl = "/api/components";
+var registryBaseUrl = "/api/views/registry";
 function setRegistryUrl(url) {
   registryBaseUrl = url;
 }
@@ -1013,19 +1065,15 @@ async function resolveVersionFromApi(id, specifier, apiKey) {
   }
   try {
     const response = await fetch(
-      `${baseUrl}/${id}/versions?specifier=${encodeURIComponent(specifier)}`,
+      `${baseUrl}/${id}/resolve?specifier=${encodeURIComponent(specifier)}`,
       { headers }
     );
     if (!response.ok) {
       throw new Error(`Failed to resolve version: ${response.statusText}`);
     }
     const data = await response.json();
-    if (data.success && data.data?.resolvedVersion) {
-      return data.data.resolvedVersion;
-    }
-    if (data.data?.versions) {
-      const resolved = resolveVersion(data.data.versions, specifier);
-      if (resolved) return resolved;
+    if (data.success && data.data?.resolved) {
+      return data.data.resolved;
     }
     throw new Error(data.error || "Failed to resolve version");
   } catch (error) {
@@ -1033,7 +1081,7 @@ async function resolveVersionFromApi(id, specifier, apiKey) {
     return "latest";
   }
 }
-async function fetchFromRegistry(id, version, apiKey) {
+async function fetchFromRegistry(id, version, apiKey, includeBundle) {
   const baseUrl = getRegistryUrl();
   const headers = {
     "Content-Type": "application/json"
@@ -1041,25 +1089,39 @@ async function fetchFromRegistry(id, version, apiKey) {
   if (apiKey) {
     headers["Authorization"] = `Bearer ${apiKey}`;
   }
-  const url = version && version !== "latest" ? `${baseUrl}/${id}/versions/${version}` : `${baseUrl}/${id}`;
+  let url;
+  if (version && version !== "latest" && /^\d+\.\d+\.\d+/.test(version)) {
+    url = `${baseUrl}/${id}/versions/${version}`;
+  } else if (version && version !== "latest") {
+    url = `${baseUrl}/${id}?version=${encodeURIComponent(version)}`;
+  } else {
+    url = `${baseUrl}/${id}`;
+  }
+  if (includeBundle) {
+    url += (url.includes("?") ? "&" : "?") + "bundle=true";
+  }
   const response = await fetch(url, { headers });
   if (!response.ok) {
     if (response.status === 404) {
-      throw new Error(`Component not found: ${id}@${version}`);
+      throw new Error(`View not found: ${id}@${version}`);
     }
     if (response.status === 401) {
       throw new Error("Unauthorized: Invalid or missing API key");
     }
     if (response.status === 403) {
-      throw new Error("Forbidden: Access denied to this component");
+      throw new Error("Forbidden: Access denied to this view");
     }
-    throw new Error(`Failed to fetch component: ${response.statusText}`);
+    throw new Error(`Failed to fetch view: ${response.statusText}`);
   }
   const data = await response.json();
   if (!data.success || !data.data) {
-    throw new Error(data.error || "Failed to fetch component data");
+    throw new Error(data.error || "Failed to fetch view data");
   }
-  return data.data;
+  const result = data.data;
+  if (result.viewId && !result.id) {
+    result.id = result.viewId;
+  }
+  return result;
 }
 async function fetchComponent(id, options = {}) {
   const {
@@ -1069,7 +1131,9 @@ async function fetchComponent(id, options = {}) {
     cacheConfig = DEFAULT_CACHE_CONFIG,
     retryConfig = {},
     forceRefresh = false,
-    signal
+    signal,
+    bundleStrategy = "eager",
+    includeBundle = true
   } = options;
   const fullRetryConfig = {
     ...DEFAULT_RETRY_CONFIG,
@@ -1078,10 +1142,15 @@ async function fetchComponent(id, options = {}) {
   if (!forceRefresh) {
     const cached = getFromCache(id, version, cacheStrategy, cacheConfig);
     if (cached) {
+      let registry;
+      if (cached.bundle) {
+        registry = buildRegistryFromBundle(cached);
+      }
       return {
         data: cached,
         fromCache: true,
-        version: cached.version
+        version: cached.version,
+        registry
       };
     }
   }
@@ -1089,28 +1158,46 @@ async function fetchComponent(id, options = {}) {
   if (!forceRefresh && resolvedVersion !== version) {
     const cached = getFromCache(id, resolvedVersion, cacheStrategy, cacheConfig);
     if (cached) {
+      let registry;
+      if (cached.bundle) {
+        registry = buildRegistryFromBundle(cached);
+      }
       return {
         data: cached,
         fromCache: true,
-        version: resolvedVersion
+        version: resolvedVersion,
+        registry
       };
     }
   }
   let lastError = null;
+  const shouldIncludeBundle = bundleStrategy !== "none" && includeBundle;
   for (let attempt = 0; attempt <= fullRetryConfig.maxRetries; attempt++) {
     if (signal?.aborted) {
       throw new Error("Fetch aborted");
     }
     try {
-      const data = await fetchFromRegistry(id, resolvedVersion, apiKey);
+      const data = await fetchFromRegistry(id, resolvedVersion, apiKey, shouldIncludeBundle);
       setInCache(id, resolvedVersion, data, cacheStrategy, cacheConfig);
       if (version !== resolvedVersion) {
         setInCache(id, version, data, cacheStrategy, cacheConfig);
       }
+      let registry;
+      let pendingDependencies;
+      if (data.bundle) {
+        registry = buildRegistryFromBundle(data);
+      } else if (data.dependencies && bundleStrategy === "lazy") {
+        pendingDependencies = Object.entries(data.dependencies).map(([depId, entry]) => ({
+          id: depId,
+          version: entry.resolved || entry.version
+        }));
+      }
       return {
         data,
         fromCache: false,
-        version: resolvedVersion
+        version: resolvedVersion,
+        registry,
+        pendingDependencies
       };
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
@@ -1125,10 +1212,60 @@ async function fetchComponent(id, options = {}) {
   }
   throw lastError || new Error("Failed to fetch component");
 }
+async function fetchComponentWithDependencies(id, options = {}) {
+  const result = await fetchComponent(id, { ...options, includeBundle: true });
+  if (result.pendingDependencies && result.pendingDependencies.length > 0) {
+    const { createRegistry: createRegistry2 } = await import("./registry-GCCVK65D.js");
+    const registry = result.registry || createRegistry2();
+    await Promise.all(
+      result.pendingDependencies.map(async (dep) => {
+        try {
+          const depResult = await fetchComponent(dep.id, {
+            ...options,
+            version: dep.version,
+            bundleStrategy: "none"
+            // Don't recursively bundle
+          });
+          registry.set(dep.id, depResult.version, {
+            layout: depResult.data.layout,
+            propsInterface: depResult.data.propsInterface
+          });
+        } catch (err) {
+          console.warn(`Failed to fetch dependency ${dep.id}:`, err);
+        }
+      })
+    );
+    result.registry = registry;
+    result.pendingDependencies = void 0;
+  }
+  return result;
+}
+async function batchFetchComponents(components, options = {}) {
+  const baseUrl = getRegistryUrl();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (options.apiKey) {
+    headers["Authorization"] = `Bearer ${options.apiKey}`;
+  }
+  const response = await fetch(`${baseUrl}/batch`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ components })
+  });
+  if (!response.ok) {
+    throw new Error(`Batch fetch failed: ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (!data.success || !data.data) {
+    throw new Error(data.error || "Batch fetch failed");
+  }
+  return data.data;
+}
 async function prefetchComponents(ids, options = {}) {
   const promises = ids.map(
     ({ id, version }) => fetchComponent(id, { ...options, version }).catch((error) => {
-      console.warn(`Failed to prefetch component ${id}:`, error);
+      console.warn(`Failed to prefetch view ${id}:`, error);
     })
   );
   await Promise.all(promises);
@@ -1137,19 +1274,164 @@ async function isComponentAvailable(id, version = "latest", options = {}) {
   const { cacheStrategy = "memory", cacheConfig = DEFAULT_CACHE_CONFIG } = options;
   const cached = getFromCache(id, version, cacheStrategy, cacheConfig);
   if (cached) {
-    return { available: true, cached: true };
+    return { available: true, cached: true, version: cached.version };
+  }
+  const baseUrl = getRegistryUrl();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (options.apiKey) {
+    headers["Authorization"] = `Bearer ${options.apiKey}`;
   }
   try {
-    await fetchComponent(id, {
-      ...options,
-      version,
-      retryConfig: { maxRetries: 0 }
-    });
-    return { available: true, cached: false };
+    const url = version && version !== "latest" ? `${baseUrl}/${id}/available?version=${encodeURIComponent(version)}` : `${baseUrl}/${id}/available`;
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      return { available: false, cached: false };
+    }
+    const data = await response.json();
+    if (data.success && data.data) {
+      return data.data;
+    }
+    return { available: false, cached: false };
   } catch {
     return { available: false, cached: false };
   }
 }
+async function getDependencyTree(id, options = {}) {
+  const baseUrl = getRegistryUrl();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (options.apiKey) {
+    headers["Authorization"] = `Bearer ${options.apiKey}`;
+  }
+  const params = new URLSearchParams();
+  if (options.version) params.set("version", options.version);
+  if (options.depth) params.set("depth", String(options.depth));
+  const url = `${baseUrl}/${id}/dependencies${params.toString() ? "?" + params.toString() : ""}`;
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    throw new Error(`Failed to get dependency tree: ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (!data.success || !data.data) {
+    throw new Error(data.error || "Failed to get dependency tree");
+  }
+  return data.data;
+}
+
+// src/version.ts
+function parseVersion(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) return null;
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10)
+  };
+}
+function compareVersions(a, b) {
+  const parsedA = parseVersion(a);
+  const parsedB = parseVersion(b);
+  if (!parsedA || !parsedB) return 0;
+  if (parsedA.major !== parsedB.major) {
+    return parsedA.major > parsedB.major ? 1 : -1;
+  }
+  if (parsedA.minor !== parsedB.minor) {
+    return parsedA.minor > parsedB.minor ? 1 : -1;
+  }
+  if (parsedA.patch !== parsedB.patch) {
+    return parsedA.patch > parsedB.patch ? 1 : -1;
+  }
+  return 0;
+}
+function satisfiesVersion(version, specifier) {
+  if (specifier === "latest" || specifier === "*") {
+    return true;
+  }
+  const parsed = parseVersion(version);
+  if (!parsed) return false;
+  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
+    return version === specifier;
+  }
+  if (specifier.startsWith("^")) {
+    const specParsed = parseVersion(specifier.slice(1));
+    if (!specParsed) return false;
+    if (parsed.major !== specParsed.major) return false;
+    if (parsed.major === 0) {
+      return parsed.minor === specParsed.minor && parsed.patch >= specParsed.patch;
+    }
+    return compareVersions(version, specifier.slice(1)) >= 0;
+  }
+  if (specifier.startsWith("~")) {
+    const specParsed = parseVersion(specifier.slice(1));
+    if (!specParsed) return false;
+    return parsed.major === specParsed.major && parsed.minor === specParsed.minor && parsed.patch >= specParsed.patch;
+  }
+  if (specifier.startsWith(">=")) {
+    return compareVersions(version, specifier.slice(2)) >= 0;
+  }
+  if (specifier.startsWith(">")) {
+    return compareVersions(version, specifier.slice(1)) > 0;
+  }
+  if (specifier.startsWith("<=")) {
+    return compareVersions(version, specifier.slice(2)) <= 0;
+  }
+  if (specifier.startsWith("<")) {
+    return compareVersions(version, specifier.slice(1)) < 0;
+  }
+  return false;
+}
+function resolveVersion(versions, specifier = "latest") {
+  if (versions.length === 0) {
+    return null;
+  }
+  const sorted = [...versions].sort((a, b) => compareVersions(b, a));
+  if (specifier === "latest" || specifier === "*") {
+    return sorted[0];
+  }
+  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
+    return versions.includes(specifier) ? specifier : null;
+  }
+  for (const version of sorted) {
+    if (satisfiesVersion(version, specifier)) {
+      return version;
+    }
+  }
+  return null;
+}
+function bumpVersion(currentVersion, bumpType) {
+  const parsed = parseVersion(currentVersion);
+  if (!parsed) return "1.0.0";
+  switch (bumpType) {
+    case "major":
+      return `${parsed.major + 1}.0.0`;
+    case "minor":
+      return `${parsed.major}.${parsed.minor + 1}.0`;
+    case "patch":
+      return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+    default:
+      return currentVersion;
+  }
+}
+function isValidSpecifier(specifier) {
+  if (specifier === "latest" || specifier === "*") {
+    return true;
+  }
+  if (/^\d+\.\d+\.\d+$/.test(specifier)) {
+    return true;
+  }
+  if (/^[\^~><]=?\d+\.\d+\.\d+$/.test(specifier)) {
+    return true;
+  }
+  return false;
+}
+function formatVersion(version) {
+  const parsed = parseVersion(version);
+  if (!parsed) return version;
+  return `v${parsed.major}.${parsed.minor}.${parsed.patch}`;
+}
 
 // src/testRunner.ts
 function runTestCase(elements, testCase, container) {
@@ -1409,21 +1691,30 @@ export {
   DEFAULT_CACHE_CONFIG,
   DEFAULT_RETRY_CONFIG,
   applyStyles,
+  batchFetchComponents,
   buildClassName,
   buildElementStyles,
+  buildRegistryFromBundle,
   bumpVersion,
   camelToKebab,
   clearAllCaches,
   clearLocalStorageCache,
   clearMemoryCache,
   clearStyles,
+  collectAllDependencies,
   compareVersions,
+  createRegistry,
+  detectCircularDependencies,
   extractBindingKeys,
+  extractDependencies,
+  extractDependenciesFromCode,
   fetchComponent,
+  fetchComponentWithDependencies,
   formatStyleValue,
   formatVersion,
   generateTestCases,
   getCacheKey,
+  getDependencyTree,
   getFromCache,
   getMemoryCacheSize,
   getRegistryUrl,
@@ -1435,6 +1726,7 @@ export {
   prefetchComponents,
   processStyles,
   render,
+  renderDynamicList,
   resolveBindingPath,
   resolveTemplate,
   resolveTemplateValue,