@ecopages/core 0.2.0-beta.9 → 0.2.0-rc.1

package/src/build/server-entry-build-cache.js

@@ -1,169 +0,0 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { getAppServerBuildPlugins } from "./build-adapter.js";
-import { createBuildInputsFingerprint } from "./build-input-fingerprint.js";
-import { getCorePackageVersion } from "../services/module-loading/route-module-build-manifest.js";
-import {
-  RouteModuleDependencyHasher,
-  createRouteModuleDependencyHashes
-} from "../services/module-loading/route-module-dependency-hasher.js";
-import { resolveInternalExecutionDir } from "../utils/resolve-work-dir.js";
-import { SERVER_BUNDLE_DIR, SERVER_BUNDLE_FILENAME } from "../utils/resolve-entry-file.js";
-import { ROUTE_MODULE_BUILD_CACHE_FILENAME } from "../services/module-loading/route-module-build-manifest.js";
-const SERVER_ENTRY_BUILD_CACHE_FILENAME = ROUTE_MODULE_BUILD_CACHE_FILENAME;
-const SERVER_BUNDLE_MANIFEST_FILENAME = "manifest.json";
-function getServerEntryCacheDir(appConfig) {
-  return path.join(resolveInternalExecutionDir(appConfig), ".server-entry");
-}
-function getServerEntryCacheManifestPath(appConfig) {
-  return path.join(getServerEntryCacheDir(appConfig), SERVER_ENTRY_BUILD_CACHE_FILENAME);
-}
-function hashDependencyGraph(entryPath, dependencyGraph, hasher, rootDir) {
-  if (!dependencyGraph) {
-    return { [path.resolve(entryPath)]: fileSystem.hash(entryPath) };
-  }
-  return createRouteModuleDependencyHashes(hasher, { dependencyGraph }, entryPath, rootDir);
-}
-function createServerEntryBuildKey(appConfig) {
-  try {
-    const plugins = getAppServerBuildPlugins(appConfig);
-    const pluginNames = plugins.map((plugin) => plugin.name).sort().join("|");
-    return ["node", "esm", "external-packages", pluginNames].join("::");
-  } catch {
-    return "node::esm::external-packages";
-  }
-}
-function getServerBundleOutputPaths(appConfig) {
-  const distDir = appConfig.absolutePaths?.distDir ?? path.join(appConfig.rootDir, appConfig.distDir);
-  const serverOutdir = path.join(distDir, SERVER_BUNDLE_DIR);
-  const serverEntryPath = path.join(serverOutdir, SERVER_BUNDLE_FILENAME);
-  const manifestPath = path.join(serverOutdir, SERVER_BUNDLE_MANIFEST_FILENAME);
-  return { distDir, serverOutdir, serverEntryPath, manifestPath };
-}
-function readServerEntryBuildCacheManifest(appConfig) {
-  const manifestPath = getServerEntryCacheManifestPath(appConfig);
-  if (!fileSystem.exists(manifestPath)) {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(fileSystem.readFileSync(manifestPath));
-    if (!parsed || typeof parsed !== "object") {
-      return void 0;
-    }
-    return parsed;
-  } catch {
-    return void 0;
-  }
-}
-function writeServerEntryBuildCacheManifest(appConfig, manifest) {
-  const cacheDir = getServerEntryCacheDir(appConfig);
-  fileSystem.ensureDir(cacheDir);
-  fileSystem.write(
-    path.join(cacheDir, SERVER_ENTRY_BUILD_CACHE_FILENAME),
-    `${JSON.stringify(manifest, null, "	")}
-`
-  );
-}
-function writeServerBundleDeployManifest(appConfig, serverEntryPath) {
-  const { distDir, manifestPath } = getServerBundleOutputPaths(appConfig);
-  fileSystem.ensureDir(path.dirname(manifestPath));
-  const payload = {
-    serverEntry: path.relative(path.dirname(manifestPath), serverEntryPath) || SERVER_BUNDLE_FILENAME,
-    distDir,
-    builtAt: Date.now()
-  };
-  fileSystem.write(manifestPath, `${JSON.stringify(payload, null, "	")}
-`);
-}
-function lookupServerEntryBuildCache(options) {
-  if (options.force) {
-    return void 0;
-  }
-  if (process.env.NODE_ENV !== "production") {
-    return void 0;
-  }
-  const entryPath = path.resolve(options.entryPath);
-  const entryHash = fileSystem.hash(entryPath);
-  const buildInputsFingerprint = createBuildInputsFingerprint(options.appConfig);
-  const buildKey = createServerEntryBuildKey(options.appConfig);
-  const manifest = readServerEntryBuildCacheManifest(options.appConfig);
-  if (!manifest) {
-    return void 0;
-  }
-  if (manifest.invalidationVersion !== getCorePackageVersion()) {
-    return void 0;
-  }
-  if (manifest.entryPath !== entryPath || manifest.entryHash !== entryHash || manifest.buildInputsFingerprint !== buildInputsFingerprint || manifest.buildKey !== buildKey) {
-    return void 0;
-  }
-  const hasher = new RouteModuleDependencyHasher();
-  if (!hasher.matchesStoredHashes(manifest.dependencyHashes, entryPath, entryHash)) {
-    return void 0;
-  }
-  const existingOutputs = manifest.outputPaths.filter((outputPath) => fileSystem.exists(outputPath));
-  if (existingOutputs.length === 0) {
-    return void 0;
-  }
-  return {
-    manifest,
-    outputPaths: existingOutputs
-  };
-}
-function recordServerEntryBuildCache(options) {
-  if (process.env.NODE_ENV !== "production") {
-    return;
-  }
-  const entryPath = path.resolve(options.entryPath);
-  const entryHash = fileSystem.hash(entryPath);
-  const hasher = new RouteModuleDependencyHasher();
-  const dependencyHashes = hashDependencyGraph(
-    entryPath,
-    options.buildResult.dependencyGraph,
-    hasher,
-    options.appConfig.rootDir
-  );
-  const manifest = {
-    invalidationVersion: getCorePackageVersion(),
-    entryPath,
-    entryHash,
-    buildInputsFingerprint: createBuildInputsFingerprint(options.appConfig),
-    buildKey: createServerEntryBuildKey(options.appConfig),
-    outputPaths: options.outputPaths,
-    dependencyHashes,
-    builtAt: Date.now()
-  };
-  writeServerEntryBuildCacheManifest(options.appConfig, manifest);
-}
-function resolveProductionServerEntry(cwd = process.cwd()) {
-  const manifestPath = path.join(cwd, "dist", SERVER_BUNDLE_DIR, SERVER_BUNDLE_MANIFEST_FILENAME);
-  if (fileSystem.exists(manifestPath)) {
-    try {
-      const parsed = JSON.parse(fileSystem.readFileSync(manifestPath));
-      if (parsed?.serverEntry) {
-        const fromManifest = path.isAbsolute(parsed.serverEntry) ? parsed.serverEntry : path.join(path.dirname(manifestPath), parsed.serverEntry);
-        if (fileSystem.exists(fromManifest)) {
-          return fromManifest;
-        }
-      }
-      if (parsed?.distDir) {
-        const fromDistDir = path.join(parsed.distDir, SERVER_BUNDLE_DIR, SERVER_BUNDLE_FILENAME);
-        if (fileSystem.exists(fromDistDir)) {
-          return fromDistDir;
-        }
-      }
-    } catch {
-    }
-  }
-  const legacyPath = path.join(cwd, "dist", SERVER_BUNDLE_DIR, SERVER_BUNDLE_FILENAME);
-  return fileSystem.exists(legacyPath) ? legacyPath : void 0;
-}
-export {
-  SERVER_BUNDLE_MANIFEST_FILENAME,
-  SERVER_ENTRY_BUILD_CACHE_FILENAME,
-  getServerBundleOutputPaths,
-  lookupServerEntryBuildCache,
-  readServerEntryBuildCacheManifest,
-  recordServerEntryBuildCache,
-  resolveProductionServerEntry,
-  writeServerBundleDeployManifest
-};

package/src/build/server-side-css-shim-plugin.js

@@ -1,35 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-const CSS_PATH = /\.css$/u;
-const CSS_QUERY = "?ecopages-css-shim";
-function stripShimQuery(id) {
-  const queryIndex = id.indexOf("?");
-  return queryIndex === -1 ? id : id.slice(0, queryIndex);
-}
-function createServerSideCssShimPlugin() {
-  return {
-    name: "ecopages:server-side-css-shim",
-    async resolveId(source, importer) {
-      if (!CSS_PATH.test(source)) {
-        return null;
-      }
-      const resolved = importer ? path.resolve(path.dirname(importer), source) : path.resolve(source);
-      return existsSync(resolved) ? `${resolved}${CSS_QUERY}` : null;
-    },
-    async load(id) {
-      if (!id.endsWith(CSS_QUERY)) {
-        return null;
-      }
-      const realPath = stripShimQuery(id);
-      readFileSync(realPath, "utf-8");
-      return {
-        code: 'export default "";',
-        moduleType: "js",
-        moduleSideEffects: true
-      };
-    }
-  };
-}
-export {
-  createServerSideCssShimPlugin
-};

package/src/hmr/hmr.postcss.test.e2e.js

@@ -1,31 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { readFileSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-const FIXTURE_DIR = resolve(process.cwd(), "packages/core/__fixtures__/app");
-const TEST_CSS_FILE = resolve(FIXTURE_DIR, "src/pages/postcss-hmr.css");
-test.describe("HMR E2E PostCSS", () => {
-  test("should hot-update processor-owned CSS without a full page reload", async ({ page }) => {
-    const originalCss = readFileSync(TEST_CSS_FILE, "utf-8");
-    const title = page.locator(".postcss-title").first();
-    try {
-      await page.goto("/postcss-hmr", { waitUntil: "networkidle" });
-      await expect(title).toBeVisible();
-      const initialColor = await title.evaluate((el) => getComputedStyle(el).color);
-      expect(initialColor).toBeTruthy();
-      await page.evaluate(() => {
-        window.__postcssReloadProbe = "before-change";
-      });
-      const modifiedCss = originalCss.replace(".postcss-title {", ".postcss-title {\n	color: rgb(255, 0, 0);");
-      await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
-      await expect.poll(async () => title.evaluate((el) => getComputedStyle(el).color), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
-      await expect(
-        page.evaluate(
-          () => window.__postcssReloadProbe ?? null
-        )
-      ).resolves.toBe("before-change");
-    } finally {
-      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
-    }
-  });
-});

package/src/hmr/hmr.test.e2e.js

@@ -1,54 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { readFileSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-const FIXTURE_DIR = resolve(process.cwd(), "packages/core/__fixtures__/app");
-const TEST_CSS_FILE = resolve(FIXTURE_DIR, "src/pages/index.css");
-async function readMainTitleColor(page) {
-  return page.evaluate(() => {
-    const element = document.querySelector(".main-title");
-    if (!(element instanceof HTMLElement)) {
-      return "";
-    }
-    return getComputedStyle(element).color;
-  });
-}
-test.describe("HMR E2E", () => {
-  test("should load page with .main-title element", async ({ page }) => {
-    await page.goto("/", { waitUntil: "networkidle" });
-    const title = page.locator(".main-title").first();
-    await expect(title).toBeVisible();
-  });
-  test("should connect to HMR WebSocket", async ({ page }) => {
-    const socketPromise = page.waitForEvent("websocket", {
-      predicate: (socket2) => socket2.url().endsWith("/_hmr"),
-      timeout: 1e4
-    });
-    await page.goto("/", { waitUntil: "networkidle" });
-    const socket = await socketPromise;
-    expect(socket.url()).toMatch(/\/_hmr$/);
-  });
-  test("should fall back to a full page reload when raw CSS file changes", async ({ page }) => {
-    const originalCss = readFileSync(TEST_CSS_FILE, "utf-8");
-    const title = page.locator(".main-title").first();
-    try {
-      await page.goto("/", { waitUntil: "domcontentloaded" });
-      await expect(title).toBeVisible();
-      await expect.poll(async () => readMainTitleColor(page), { timeout: 1e4 }).not.toBe("");
-      const initialColor = await readMainTitleColor(page);
-      expect(initialColor).toBeTruthy();
-      const modifiedCss = originalCss.replace(".main-title {", ".main-title {\n	color: rgb(255, 0, 0);");
-      const reloadPromise = page.waitForEvent("framenavigated", {
-        predicate: (frame) => frame === page.mainFrame(),
-        timeout: 1e4
-      });
-      await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
-      await reloadPromise;
-      await page.waitForLoadState("domcontentloaded");
-      await expect(title).toBeVisible();
-      await expect.poll(async () => readMainTitleColor(page), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
-    } finally {
-      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
-    }
-  });
-});

package/src/integrations/ghtml/ghtml-renderer.js

@@ -1,57 +0,0 @@
-import {
-  IntegrationRenderer
-} from "../../route-renderer/orchestration/integration-renderer.js";
-import { GHTML_PLUGIN_NAME } from "./ghtml.constants.js";
-class GhtmlRenderer extends IntegrationRenderer {
-  name = GHTML_PLUGIN_NAME;
-  async renderComponent(input) {
-    return this.renderStringComponentWithQueuedForeignSubtrees(
-      input,
-      input.component
-    );
-  }
-  async render({
-    params,
-    query,
-    props,
-    locals,
-    pageLocals,
-    metadata,
-    Page,
-    Layout,
-    HtmlTemplate
-  }) {
-    try {
-      return await this.renderPageWithDocumentShell({
-        page: {
-          component: Page,
-          props: { params, query, ...props, locals: pageLocals }
-        },
-        layout: Layout ? {
-          component: Layout,
-          props: locals ? { locals } : {}
-        } : void 0,
-        htmlTemplate: HtmlTemplate,
-        metadata,
-        pageProps: props ?? {}
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering page", error);
-    }
-  }
-  async renderToResponse(view, props, ctx) {
-    try {
-      return await this.renderViewWithDocumentShell({
-        view,
-        props,
-        ctx,
-        layout: view.config?.layout
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering view", error);
-    }
-  }
-}
-export {
-  GhtmlRenderer
-};

package/src/integrations/ghtml/ghtml.constants.d.ts

@@ -1 +0,0 @@
-export declare const GHTML_PLUGIN_NAME = "ghtml";

package/src/integrations/ghtml/ghtml.constants.js

@@ -1,4 +0,0 @@
-const GHTML_PLUGIN_NAME = "ghtml";
-export {
-  GHTML_PLUGIN_NAME
-};

package/src/integrations/ghtml/ghtml.plugin.d.ts

@@ -1,16 +0,0 @@
-import { IntegrationPlugin, type IntegrationPluginConfig } from '../../plugins/integration-plugin.js';
-import { GhtmlRenderer } from './ghtml-renderer.js';
-/**
- * The Ghtml plugin class
- * This plugin provides support for ghtml components in Ecopages
- */
-export declare class GhtmlPlugin extends IntegrationPlugin {
-    renderer: typeof GhtmlRenderer;
-    constructor(options?: Omit<IntegrationPluginConfig, 'name'>);
-}
-/**
- * Factory function to create a Ghtml plugin instance
- * @param options Configuration options for the Ghtml plugin
- * @returns A new GhtmlPlugin instance
- */
-export declare function ghtmlPlugin(options?: Omit<IntegrationPluginConfig, 'name'>): GhtmlPlugin;

package/src/integrations/ghtml/ghtml.plugin.js

@@ -1,20 +0,0 @@
-import { IntegrationPlugin } from "../../plugins/integration-plugin.js";
-import { GhtmlRenderer } from "./ghtml-renderer.js";
-import { GHTML_PLUGIN_NAME } from "./ghtml.constants.js";
-class GhtmlPlugin extends IntegrationPlugin {
-  renderer = GhtmlRenderer;
-  constructor(options) {
-    super({
-      name: GHTML_PLUGIN_NAME,
-      extensions: [".ghtml.ts", ".ghtml.tsx", ".ghtml"],
-      ...options
-    });
-  }
-}
-function ghtmlPlugin(options) {
-  return new GhtmlPlugin(options);
-}
-export {
-  GhtmlPlugin,
-  ghtmlPlugin
-};

package/src/route-renderer/orchestration/component-render-context.js

@@ -1,147 +0,0 @@
-import { addTriggerAttribute, isThenable, wrapWithScriptsInjector } from "./render-output.utils.js";
-class ComponentRenderOutputRuntime {
-  finalizeComponentRender(component, content) {
-    const lazyTriggers = component.config?._resolvedLazyTriggers;
-    if (lazyTriggers && lazyTriggers.length > 0) {
-      return this.addTriggerToContent(content, lazyTriggers[0].triggerId);
-    }
-    const lazyGroups = component.config?._resolvedLazyScripts;
-    if (lazyGroups && lazyGroups.length > 0) {
-      return this.wrapContentWithScriptsInjector(content, lazyGroups);
-    }
-    return content;
-  }
-  addTriggerToContent(content, triggerId) {
-    if (isThenable(content)) {
-      return content.then((resolvedContent) => addTriggerAttribute(resolvedContent, triggerId));
-    }
-    return addTriggerAttribute(content, triggerId);
-  }
-  wrapContentWithScriptsInjector(content, lazyGroups) {
-    if (isThenable(content)) {
-      return content.then((resolvedContent) => wrapWithScriptsInjector(resolvedContent, lazyGroups));
-    }
-    return wrapWithScriptsInjector(content, lazyGroups);
-  }
-}
-class ContextualComponentRenderRuntime extends ComponentRenderOutputRuntime {
-  context;
-  constructor(context) {
-    super();
-    this.context = context;
-  }
-  applyForeignChildInterceptionResult(result) {
-    if (result.kind === "resolved") {
-      return result;
-    }
-    return result.props ? result : void 0;
-  }
-  /**
-   * Resolves one foreign-child interception through the active runtime.
-   *
-   * The runtime may choose inline rendering or immediate resolved output.
-   */
-  interceptForeignChild(input) {
-    const foreignChildRuntimeInput = {
-      currentIntegration: this.context.currentIntegration,
-      targetIntegration: input.targetIntegration,
-      component: input.component,
-      props: input.props
-    };
-    const asyncInterception = this.context.foreignChildRuntime?.interceptForeignChild?.(foreignChildRuntimeInput);
-    if (asyncInterception !== void 0) {
-      if (isThenable(asyncInterception)) {
-        return asyncInterception.then((result) => this.applyForeignChildInterceptionResult(result));
-      }
-      return this.applyForeignChildInterceptionResult(asyncInterception);
-    }
-    const syncInterception = this.context.foreignChildRuntime?.interceptForeignChildSync?.(foreignChildRuntimeInput);
-    if (syncInterception === void 0) {
-      return void 0;
-    }
-    return this.applyForeignChildInterceptionResult(syncInterception);
-  }
-}
-const GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY = "__ECOPAGES_COMPONENT_RENDER_CONTEXT_STATE__";
-function getSharedContextScope() {
-  const globalProcess = globalThis.process;
-  if (globalProcess && typeof globalProcess === "object") {
-    return globalProcess;
-  }
-  return globalThis;
-}
-function getComponentRenderContextState() {
-  const sharedScope = getSharedContextScope();
-  sharedScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY] ??= {
-    contextStack: [],
-    nodeContextStorage: null,
-    nodeContextStorageLoader: null
-  };
-  return sharedScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY];
-}
-async function getContextStorage() {
-  const state = getComponentRenderContextState();
-  if (state.nodeContextStorage) {
-    return state.nodeContextStorage;
-  }
-  if (state.nodeContextStorageLoader) {
-    return state.nodeContextStorageLoader;
-  }
-  state.nodeContextStorageLoader = import("node:async_hooks").then((module) => {
-    const storage = new module.AsyncLocalStorage();
-    state.nodeContextStorage = {
-      getStore: () => storage.getStore(),
-      run: (store, callback) => storage.run(store, callback)
-    };
-    return state.nodeContextStorage;
-  }).catch(() => {
-    state.nodeContextStorage = null;
-    return null;
-  }).finally(() => {
-    state.nodeContextStorageLoader = null;
-  });
-  return state.nodeContextStorageLoader;
-}
-function getComponentRenderContext() {
-  const state = getComponentRenderContextState();
-  return state.nodeContextStorage?.getStore() ?? state.contextStack[state.contextStack.length - 1];
-}
-const componentRenderOutputRuntime = new ComponentRenderOutputRuntime();
-function interceptForeignChild(input) {
-  return getComponentRenderContext()?.interceptForeignChild(input);
-}
-function finalizeComponentRender(component, content) {
-  const renderContext = getComponentRenderContext();
-  return renderContext?.finalizeComponentRender(component, content) ?? componentRenderOutputRuntime.finalizeComponentRender(component, content);
-}
-async function runWithComponentRenderContext(input, render) {
-  const context = {
-    currentIntegration: input.currentIntegration,
-    foreignChildRuntime: input.foreignChildRuntime
-  };
-  const runtime = new ContextualComponentRenderRuntime(context);
-  context.interceptForeignChild = (deferredInput) => runtime.interceptForeignChild(deferredInput);
-  context.finalizeComponentRender = (component, content) => runtime.finalizeComponentRender(component, content);
-  const storage = await getContextStorage();
-  let value;
-  if (storage) {
-    value = await storage.run(context, render);
-  } else {
-    const state = getComponentRenderContextState();
-    state.contextStack.push(context);
-    try {
-      value = await render();
-    } finally {
-      state.contextStack.pop();
-    }
-  }
-  return {
-    value
-  };
-}
-export {
-  finalizeComponentRender,
-  getComponentRenderContext,
-  interceptForeignChild,
-  runWithComponentRenderContext
-};

package/src/route-renderer/orchestration/declared-ownership-graph.d.ts

@@ -1,18 +0,0 @@
-import type { EcoComponent, OwnershipPlanNodeSource } from '../../types/public-types.js';
-export type DeclaredOwnershipRoot = {
-    component: EcoComponent;
-    source: Extract<OwnershipPlanNodeSource, 'page' | 'layout' | 'html-template'>;
-};
-export type DeclaredOwnershipNodeInput = {
-    component: EcoComponent;
-    source: Exclude<OwnershipPlanNodeSource, 'route'>;
-    parentIntegrationName: string;
-    integrationName: string;
-    componentId: string;
-    isForeignToParent: boolean;
-};
-export declare function mapDeclaredOwnershipGraph<T>(input: {
-    roots: DeclaredOwnershipRoot[];
-    currentIntegrationName: string;
-    mapNode: (node: DeclaredOwnershipNodeInput, children: T[]) => T;
-}): T[];

package/src/route-renderer/orchestration/declared-ownership-graph.js

@@ -1,34 +0,0 @@
-function mapDeclaredOwnershipGraph(input) {
-  let nextSyntheticId = 0;
-  const mapComponent = (component, source, parentIntegrationName, lineage) => {
-    const integrationName = component.config?.integration ?? component.config?.__eco?.integration ?? parentIntegrationName;
-    const componentMeta = component.config?.__eco;
-    const isForeignToParent = integrationName !== parentIntegrationName;
-    const componentId = componentMeta?.id ?? componentMeta?.file ?? `${source}:${nextSyntheticId += 1}`;
-    const nextLineage = new Set(lineage);
-    nextLineage.add(component);
-    const children = (component.config?.dependencies?.components ?? []).flatMap((child) => {
-      if (!child || nextLineage.has(child)) {
-        return [];
-      }
-      return [mapComponent(child, "dependency", integrationName, nextLineage)];
-    });
-    return input.mapNode(
-      {
-        component,
-        source,
-        parentIntegrationName,
-        integrationName,
-        componentId,
-        isForeignToParent
-      },
-      children
-    );
-  };
-  return input.roots.map(
-    ({ component, source }) => mapComponent(component, source, input.currentIntegrationName, /* @__PURE__ */ new Set())
-  );
-}
-export {
-  mapDeclaredOwnershipGraph
-};