@arcote.tech/arc-cli 0.7.31 → 0.8.0

package/src/platform/server.ts

@@ -7,8 +7,12 @@ import {
   type ArcRequestContext,
   type ArcServer,
 } from "@arcote.tech/arc-host";
+import { timingSafeEqual } from "crypto";
 import { existsSync, mkdirSync } from "fs";
 import { join } from "path";
+// Subpath `/types` jest bezzależnościowy — import z korzenia arc-map wciągnąłby
+// ts-morph do każdego startu platformy (startup.ts importuje mapę leniwie).
+import { MAP_SCHEMA_VERSION } from "@arcote.tech/arc-map/types";
 import { readTranslationsConfig } from "../i18n";
 import { err, ok, type BuildManifest, type WorkspaceInfo } from "./shared";
 import type { BuildManifestGroup, ModuleAccess } from "@arcote.tech/platform";
@@ -29,6 +33,12 @@ export interface PlatformServerOptions {
   dbPath?: string;
   /** If true, enables SSE reload stream + mutable manifest (dev mode) */
   devMode?: boolean;
+  /**
+   * Headless (spec/platform-headless.md): host API + chunki + manifesty BEZ
+   * shella SPA — `/` zwraca JSON info. Dla aplikacji rozwijanych jako moduły
+   * federowane konsumowane przez hosta (BMF).
+   */
+  headless?: boolean;
   /**
    * Cross-origin isolation policy. Default `"unsafe-none"`. Apps z SQLite
    * WASM/OPFS lub SharedArrayBuffer ustawiają `"require-corp"` w
@@ -36,6 +46,22 @@ export interface PlatformServerOptions {
    * widgets) musi mieć `Cross-Origin-Resource-Policy`. Patrz `ArcServerConfig.coep`.
    */
   coep?: "unsafe-none" | "credentialless" | "require-corp";
+  /**
+   * Federacja: dane do `POST /api/federation/register` — kanał, którym host
+   * (BMF) przedstawia się aplikacji i POBIERA jej sekret. Obecne tylko gdy
+   * aplikacja wystawia moduły (`manifest.federation`).
+   */
+  federation?: {
+    /** Token parowania — ten sam, który deweloper wkleja hostowi. */
+    registrationToken: string;
+    /** Sekret aplikacji (`ARC_APP_SECRET`) — host podpisuje nim asercje. */
+    appSecret: string;
+  };
+  /**
+   * Adres mapy — ogłaszany w `/api/discovery`, żeby host wiedział, gdzie żyje
+   * sync elementów i use-case'y. Tylko dev: w prod mapa nie startuje.
+   */
+  mapUrl?: string;
 }
 
 export interface PlatformServer {
@@ -44,6 +70,11 @@ export interface PlatformServer {
   connectionManager: ConnectionManager | null;
   /** Update manifest at runtime (dev mode rebuild) */
   setManifest: (m: BuildManifest) => void;
+  /**
+   * Ogłoś adres mapy w `/api/discovery`. Mapa startuje PO platformie (na jej
+   * porcie +1), więc adres znamy dopiero później. Dev-only.
+   */
+  setMapUrl: (url: string) => void;
   /** Notify SSE clients of rebuild (dev mode only) */
   notifyReload: (m: BuildManifest) => void;
   /** Cleanup streams and stop server */
@@ -102,6 +133,10 @@ export function generateShellHtml(
   manifest?: { title: string; favicon?: string },
   initial?: { file: string; hash: string },
   stylesHash?: string,
+  shell?: {
+    imports: Readonly<Record<string, string>>;
+    peers: Readonly<Record<string, string>>;
+  },
 ): string {
   // OpenTelemetry config — injected as a global so the browser SDK chunk
   // (lazy-loaded by start-app.ts) can pick it up without a fetch. Endpoint
@@ -119,12 +154,19 @@ export function generateShellHtml(
     ? `\n  <script>window.__ARC_OTEL_CONFIG=${JSON.stringify(otelConfig)};</script>`
     : "";
   // Initial bundle carries framework, public modules, and PlatformApp re-export.
-  // No importmap — single Bun.build with splitting:true inlines + dedups everything
-  // across initial and per-token group bundles via auto-emitted chunk-<hash>.js.
+  // Bundled build: no importmap — splitting:true dedups everything into
+  // chunk-<hash>.js. Federated build (arc.federation): framework peers są
+  // external i rozwiązuje je import mapa peer-shella; obowiązuje ona też
+  // moduły importowane cross-origin (chunki aplikacji partnerskich) —
+  // spec/module-federation.md.
   const initialUrl = initial ? `/browser/${initial.file}` : null;
   if (!initialUrl) {
     throw new Error("generateShellHtml: initial bundle missing from manifest");
   }
+  const importMapTag = shell
+    ? `\n  <script type="importmap">${JSON.stringify({ imports: shell.imports })}</script>` +
+      `\n  <script>window.__ARC_PEERS__=${JSON.stringify(shell.peers)};</script>`
+    : "";
   // Append the styles content hash as a query string. Filenames are stable
   // (/styles.css, /theme.css) but their content changes between builds; the
   // hash invalidates the browser cache exactly when the content changes,
@@ -137,7 +179,7 @@ export function generateShellHtml(
   <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover" />
   <title>${manifest?.title ?? appName}</title>${manifest?.favicon ? `\n  <link rel="icon" href="${manifest.favicon}">` : ""}${manifest ? `\n  <link rel="manifest" href="/manifest.json${stylesQs}">` : ""}
   <link rel="stylesheet" href="/styles.css${stylesQs}" />
-  <link rel="stylesheet" href="/theme.css${stylesQs}" />
+  <link rel="stylesheet" href="/theme.css${stylesQs}" />${importMapTag}
   <link rel="modulepreload" href="${initialUrl}" />${otelTag}
 </head>
 <body>
@@ -225,11 +267,51 @@ function ensureModuleSigSecret(ws: WorkspaceInfo, devMode: boolean): void {
  *   - Threat model: a stolen sig only buys access to the JS code itself —
  *     all runtime API calls re-validate the JWT independently.
  */
-function signGroupUrl(file: string): string {
+function signGroupUrl(file: string, prefix = "/browser"): string {
   const hasher = new Bun.CryptoHasher("sha256");
   hasher.update(`${file}:${MODULE_SIG_SECRET}`);
   const sig = hasher.digest("hex").slice(0, 16);
-  return `/browser/${file}?sig=${sig}`;
+  return `${prefix}/${file}?sig=${sig}`;
+}
+
+/**
+ * Filtruje grupy manifestu do tych, do których tokeny wołającego dają dostęp
+ * (per-moduł wg access map), i dokleja podpisany URL z podanym prefiksem.
+ * Współdzielone przez `/api/modules` (/browser) i federację (/browser-fed).
+ */
+async function filterGroupsForTokens(
+  groups: Readonly<Record<string, BuildManifestGroup>>,
+  moduleAccessMap: Map<string, ModuleAccess>,
+  tokenPayloads: any[],
+  urlPrefix: string,
+): Promise<Record<string, BuildManifestGroup>> {
+  const tokensByName = new Map<string, any>();
+  for (const t of tokenPayloads) {
+    if (t?.tokenType) tokensByName.set(t.tokenType, t);
+  }
+  const filtered: Record<string, BuildManifestGroup> = {};
+  for (const [name, group] of Object.entries(groups)) {
+    let allGranted = true;
+    for (const moduleName of group.modules) {
+      const access = moduleAccessMap.get(moduleName);
+      if (!access || access.rules.length === 0) continue;
+      let granted = false;
+      for (const rule of access.rules) {
+        const matching = tokensByName.get(rule.token.name);
+        if (!matching) continue;
+        granted = rule.check ? await rule.check(matching) : true;
+        if (granted) break;
+      }
+      if (!granted) {
+        allGranted = false;
+        break;
+      }
+    }
+    if (allGranted) {
+      filtered[name] = { ...group, url: signGroupUrl(group.file, urlPrefix) };
+    }
+  }
+  return filtered;
 }
 
 function verifyGroupSignature(file: string, sig: string | null): boolean {
@@ -291,39 +373,12 @@ async function filterManifestForTokens(
   // Chunk group names are no longer 1:1 with token names (a checked module
   // gets its own chunk `<token>__<module>`), so grant by the per-module
   // access rules, not by the group name. Look tokens up by their name.
-  const tokensByName = new Map<string, any>();
-  for (const t of tokenPayloads) {
-    if (t?.tokenType) tokensByName.set(t.tokenType, t);
-  }
-
-  const filteredGroups: Record<string, BuildManifestGroup> = {};
-
-  for (const [name, group] of Object.entries(manifest.groups)) {
-    // Every module in the group must be granted by a held token (and pass
-    // its check, if any). Chunks are homogeneous post-split — a checked
-    // module is alone in its chunk, so its check can't block other modules.
-    let allGranted = true;
-    for (const moduleName of group.modules) {
-      const access = moduleAccessMap.get(moduleName);
-      if (!access || access.rules.length === 0) continue;
-      let granted = false;
-      for (const rule of access.rules) {
-        const matching = tokensByName.get(rule.token.name);
-        if (!matching) continue;
-        granted = rule.check ? await rule.check(matching) : true;
-        if (granted) break;
-      }
-      if (!granted) {
-        allGranted = false;
-        break;
-      }
-    }
-
-    if (allGranted) {
-      filteredGroups[name] = { ...group, url: signGroupUrl(group.file) };
-    }
-  }
-
+  const filteredGroups = await filterGroupsForTokens(
+    manifest.groups,
+    moduleAccessMap,
+    tokenPayloads,
+    "/browser",
+  );
   return {
     initial: manifest.initial,
     groups: filteredGroups,
@@ -374,6 +429,44 @@ function staticFilesHandler(
         "Cache-Control": devMode ? "no-cache" : "max-age=31536000,immutable",
       });
     }
+    // Peer-shell (federacja): singletony framework peers rozwiązywane przez
+    // import mapę shella. Content-addressed, publiczne, cross-origin (chunki
+    // hosta federacji importują je z tego originu przez import mapę).
+    if (path.startsWith("/shell/")) {
+      const file = path.slice(7);
+      if (!BROWSER_FILE_RE.test(file)) {
+        return new Response("Not Found", { status: 404, headers: ctx.corsHeaders });
+      }
+      return serveFile(join(ws.arcDir, "shell", file), {
+        ...ctx.corsHeaders,
+        "Cross-Origin-Resource-Policy": "cross-origin",
+        "Cache-Control": devMode ? "no-cache" : "max-age=31536000,immutable",
+      });
+    }
+    // Chunki modułów FEDEROWANYCH (build browser-fed/) — ładowane przez host
+    // federacji z innego originu. Group-entry podpisane (jak /browser/),
+    // shared chunki content-addressed. Cross-origin (CORS + CORP).
+    if (path.startsWith("/browser-fed/")) {
+      const file = path.slice(13);
+      if (!BROWSER_FILE_RE.test(file)) {
+        return new Response("Not Found", { status: 404, headers: ctx.corsHeaders });
+      }
+      const fed = getManifest().federation;
+      const isGroupEntry = fed
+        ? Object.values(fed.build.groups).some((g) => g.file === file)
+        : false;
+      if (isGroupEntry) {
+        const sig = url.searchParams.get("sig");
+        if (!verifyGroupSignature(file, sig)) {
+          return new Response("Forbidden", { status: 403, headers: ctx.corsHeaders });
+        }
+      }
+      return serveFile(join(ws.arcDir, "browser-fed", file), {
+        ...ctx.corsHeaders,
+        "Cross-Origin-Resource-Policy": "cross-origin",
+        "Cache-Control": devMode ? "no-cache" : "max-age=31536000,immutable",
+      });
+    }
     // Locales (compiled .po → .json) — short TTL with SWR; catalogs change
     // build-to-build but rarely within a session, and they're tiny.
     if (path.startsWith("/locales/"))
@@ -425,14 +518,198 @@ function staticFilesHandler(
   };
 }
 
+/**
+ * `ARC_CORS_ORIGINS` → allowlista originów CORS. `undefined` (brak env) zostaje
+ * `undefined`, nie pustą tablicą: pusta lista i brak listy znaczą w arc-host co
+ * innego (pusta = nikt nie przejdzie, brak = odbijaj Origin bez credentials).
+ */
+function parseCorsOrigins(raw: string | undefined): string[] | undefined {
+  if (!raw) return undefined;
+  const list = raw
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  return list.length > 0 ? list : undefined;
+}
+
+/** Porównanie sekretów w czasie stałym (bez wycieku długości prefiksu). */
+function safeEqual(a: string, b: string): boolean {
+  const ab = Buffer.from(a);
+  const bb = Buffer.from(b);
+  if (ab.length !== bb.length) return false;
+  return timingSafeEqual(ab, bb);
+}
+
+/**
+ * `GET /api/discovery` — kto tu mieszka, za tokenem parowania.
+ *
+ * Ten sam kształt odpowiedzi co discovery mapy (arc-map), ale serwowany przez
+ * PLATFORMĘ, więc żyje też na produkcji. Mapa jest narzędziem dev i w prod nie
+ * startuje (startup.ts) — a instalacja u hosta discovery WYMAGA, więc bez tego
+ * federacji nie dało się w ogóle zainstalować poza devem.
+ *
+ * Platforma to adres stabilny; mapa jest dev-owym dodatkiem OGŁASZANYM tutaj
+ * (`mapUrl`), żeby host wiedział, gdzie szukać sync-u elementów i use-case'ów.
+ * W prod `mapUrl` jest `null` i te funkcje po prostu nie są dostępne.
+ */
+function handleDiscovery(
+  req: Request,
+  ctx: ArcRequestContext,
+  ws: WorkspaceInfo,
+  manifest: BuildManifest,
+  federation?: PlatformServerOptions["federation"],
+  mapUrl?: string,
+): Response {
+  if (!federation) {
+    return new Response("Not Found", { status: 404, headers: ctx.corsHeaders });
+  }
+  const presented = req.headers.get("X-Arc-Pairing-Token");
+  if (!presented || !safeEqual(presented, federation.registrationToken)) {
+    return new Response("Unauthorized", {
+      status: 401,
+      headers: ctx.corsHeaders,
+    });
+  }
+
+  const fed = manifest.federation;
+  // Adres własny: za proxy `req.url` jest wewnętrzny, więc pozwalamy nadpisać
+  // przez env. Konsument i tak zna nas z adresu, którego użył — to pole jest
+  // potwierdzeniem, nie źródłem prawdy.
+  const platformUrl =
+    process.env.ARC_PUBLIC_URL || new URL(req.url).origin;
+
+  return Response.json(
+    {
+      meta: {
+        schemaVersion: MAP_SCHEMA_VERSION,
+        name: ws.appName,
+        version: (ws.rootPkg?.version as string | undefined) ?? undefined,
+      },
+      platformUrl,
+      federation: fed
+        ? {
+            slug: fed.config.slug,
+            auth: fed.config.auth,
+            modules: fed.modules,
+            permissions: fed.permissions,
+            slots: fed.slots,
+          }
+        : null,
+      peers: manifest.shell?.peers ?? null,
+      federationManifestUrl: fed
+        ? `${platformUrl}/api/federation/manifest`
+        : null,
+      /** Adres mapy — tylko dev; w prod `null` (mapa nie startuje). */
+      mapUrl: mapUrl ?? null,
+    },
+    { headers: { ...ctx.corsHeaders, "Cache-Control": "no-cache, private" } },
+  );
+}
+
+/**
+ * `POST /api/federation/register` — host federacji przedstawia się aplikacji
+ * i POBIERA jej sekret (spec/app-identity.md).
+ *
+ * Kierunek jest celowy: sekret NALEŻY do aplikacji (stały, `ARC_APP_SECRET`),
+ * więc ma go już przy starcie. Host go pobiera i podpisuje nim asercje
+ * tożsamości. Dzięki temu instalacja u hosta nie wymaga wklejania czegokolwiek
+ * do env partnera ani restartu — a to była przyczyna błędnego koła
+ * (instalacja → restart → nowy token parowania → parowanie martwe).
+ *
+ * Bramą jest token parowania — ten sam, który deweloper świadomie wkleja
+ * hostowi. Wywołanie jest SERVER→SERVER (sekret nigdy nie trafia do
+ * przeglądarki), więc CORS tu nie obowiązuje.
+ */
+async function handleFederationRegister(
+  req: Request,
+  ctx: ArcRequestContext,
+  manifest: BuildManifest,
+  federation?: PlatformServerOptions["federation"],
+): Promise<Response> {
+  const fed = manifest.federation;
+  if (!fed || !federation) {
+    return new Response("Not Found", { status: 404, headers: ctx.corsHeaders });
+  }
+
+  const presented = req.headers.get("X-Arc-Pairing-Token");
+  if (!presented || !safeEqual(presented, federation.registrationToken)) {
+    return new Response("Unauthorized", {
+      status: 401,
+      headers: ctx.corsHeaders,
+    });
+  }
+
+  let body: Record<string, unknown>;
+  try {
+    body = (await req.json()) as Record<string, unknown>;
+  } catch {
+    return new Response("Bad Request", {
+      status: 400,
+      headers: ctx.corsHeaders,
+    });
+  }
+
+  const hostId = typeof body.hostId === "string" ? body.hostId : "";
+  const hostUrl = typeof body.hostUrl === "string" ? body.hostUrl : "";
+  const hostName = typeof body.hostName === "string" ? body.hostName : hostId;
+  const organizationId =
+    typeof body.organizationId === "string" ? body.organizationId : "";
+  if (!hostId || !hostUrl) {
+    return new Response("Bad Request: hostId + hostUrl required", {
+      status: 400,
+      headers: ctx.corsHeaders,
+    });
+  }
+
+  // Widoczne dla dewelopera aplikacji — kto się podpiął i dla jakiej organizacji.
+  ok(
+    `Federation: host "${hostName}" (${hostUrl}) registered for org ${organizationId || "—"}`,
+  );
+
+  return Response.json(
+    {
+      secret: federation.appSecret,
+      slug: fed.config.slug,
+      auth: fed.config.auth,
+      modules: fed.modules,
+      permissions: fed.permissions,
+      slots: fed.slots,
+    },
+    { headers: { ...ctx.corsHeaders, "Cache-Control": "no-store" } },
+  );
+}
+
 function apiEndpointsHandler(
   ws: WorkspaceInfo,
   getManifest: () => BuildManifest,
   cm: ConnectionManager | null,
   moduleAccessMap: Map<string, ModuleAccess>,
   telemetry?: import("@arcote.tech/arc-otel").ArcTelemetry,
+  federation?: PlatformServerOptions["federation"],
+  getMapUrl?: () => string | undefined,
 ): ArcHttpHandler {
   return (req, url, ctx) => {
+    if (url.pathname === "/api/discovery") {
+      return handleDiscovery(
+        req,
+        ctx,
+        ws,
+        getManifest(),
+        federation,
+        getMapUrl?.(),
+      );
+    }
+    if (url.pathname === "/api/federation/register") {
+      // Łapiemy ścieżkę dla KAŻDEJ metody — inaczej GET wpadłby w fallback SPA
+      // i oddał shell HTML ze statusem 200, co myli konsumenta.
+      if (req.method !== "POST") {
+        return new Response("Method Not Allowed", {
+          status: 405,
+          headers: { ...ctx.corsHeaders, Allow: "POST, OPTIONS" },
+        });
+      }
+      return handleFederationRegister(req, ctx, getManifest(), federation);
+    }
     if (url.pathname === "/api/modules") {
       // Parse all tokens from X-Arc-Tokens header + Authorization fallback
       const arcTokensHeader = req.headers.get("X-Arc-Tokens");
@@ -456,6 +733,51 @@ function apiEndpointsHandler(
         );
     }
 
+    if (url.pathname === "/api/federation/manifest") {
+      // Manifest federacji dla HOSTA (spec/module-federation.md): artefakty z
+      // buildu FEDEROWANEGO (browser-fed/), grupy filtrowane per tokeny
+      // aplikacji (X-Arc-Tokens), wersje peers do polityki kompatybilności,
+      // meta modułów wystawionych. Dostępny, gdy aplikacja eksportuje moduły.
+      const m = getManifest();
+      if (!m.federation || !m.shell) {
+        return new Response("Not Found", { status: 404, headers: ctx.corsHeaders });
+      }
+      const arcTokensHeader = req.headers.get("X-Arc-Tokens");
+      let payloads = parseArcTokensHeader(arcTokensHeader);
+      if (payloads.length === 0 && ctx.tokenPayload) {
+        payloads = [ctx.tokenPayload];
+      }
+      const fed = m.federation;
+      return filterGroupsForTokens(
+        fed.build.groups,
+        moduleAccessMap,
+        payloads,
+        "/browser-fed",
+      ).then((groups) =>
+        Response.json(
+          {
+            initial: fed.build.initial,
+            groups,
+            sharedChunks: fed.build.sharedChunks,
+            stylesHash: m.stylesHash,
+            peers: m.shell!.peers,
+            app: {
+              slug: fed.config.slug,
+              name: ws.appName,
+              version: (ws.rootPkg.version as string | undefined) ?? undefined,
+              modules: fed.modules,
+              permissions: fed.permissions,
+              slots: fed.slots,
+              auth: fed.config.auth,
+            },
+          },
+          {
+            headers: { ...ctx.corsHeaders, "Cache-Control": "no-cache, private" },
+          },
+        ),
+      );
+    }
+
     if (url.pathname === "/api/translations") {
       const config = readTranslationsConfig(ws.rootDir);
       return Response.json(config ?? { locales: [], sourceLocale: "" }, {
@@ -515,6 +837,29 @@ function devReloadHandler(
   };
 }
 
+/**
+ * Fallback trybu headless: zamiast shella SPA `/` (i każda niestatyczna
+ * ścieżka) zwraca JSON z informacją o aplikacji — konsumenci (host federacji,
+ * ludzie z przeglądarką) widzą, że to serwer API modułów federowanych.
+ */
+function headlessFallbackHandler(
+  ws: WorkspaceInfo,
+  getManifest: () => BuildManifest,
+): ArcHttpHandler {
+  return (_req, _url, ctx) => {
+    const m = getManifest();
+    return Response.json(
+      {
+        arc: "headless",
+        app: ws.appName,
+        federation: m.federation ?? null,
+        endpoints: ["/api/federation/manifest", "/api/modules", "/health"],
+      },
+      { headers: ctx.corsHeaders },
+    );
+  };
+}
+
 function spaFallbackHandler(getShellHtml: () => string): ArcHttpHandler {
   return (_req, _url, ctx) => {
     return new Response(getShellHtml(), {
@@ -583,13 +928,29 @@ export async function startPlatformServer(
   const setManifest = (m: BuildManifest) => {
     manifest = m;
   };
+  let mapUrl = opts.mapUrl;
+  const setMapUrl = (u: string) => {
+    mapUrl = u;
+  };
+  const getMapUrl = () => mapUrl;
 
   // Recompute on every request — manifest.initial.hash changes when public
   // modules are rebuilt in dev, and we want the new URL in the HTML.
   const getShellHtml = (): string =>
-    generateShellHtml(ws.appName, ws.manifest, manifest?.initial, manifest?.stylesHash);
+    generateShellHtml(
+      ws.appName,
+      ws.manifest,
+      manifest?.initial,
+      manifest?.stylesHash,
+      manifest?.shell,
+    );
   const sseClients = new Set<ReadableStreamDefaultController>();
 
+  // Headless: bez shella SPA — fallback JSON (spec/platform-headless.md).
+  const fallbackHandler = opts.headless
+    ? headlessFallbackHandler(ws, getManifest)
+    : spaFallbackHandler(getShellHtml);
+
   const notifyReload = (m: BuildManifest) => {
     const data = JSON.stringify(m);
     for (const c of sseClients) {
@@ -619,8 +980,15 @@ export async function startPlatformServer(
       port,
       async fetch(req) {
         const url = new URL(req.url);
-        if (req.method === "OPTIONS")
-          return new Response(null, { headers: cors });
+        if (req.method === "OPTIONS") {
+          const headers: Record<string, string> = { ...cors };
+          // Private Network Access (Chrome): hostowany host federacji (https)
+          // → localhost dewelopera wymaga jawnej zgody na preflight.
+          if (req.headers.get("Access-Control-Request-Private-Network")) {
+            headers["Access-Control-Allow-Private-Network"] = "true";
+          }
+          return new Response(null, { headers });
+        }
 
         const ctx: ArcRequestContext = {
           rawToken: null,
@@ -630,10 +998,18 @@ export async function startPlatformServer(
 
         // Platform handlers only
         const handlers: ArcHttpHandler[] = [
-          apiEndpointsHandler(ws, getManifest, null, moduleAccessMap, telemetry),
+          apiEndpointsHandler(
+        ws,
+        getManifest,
+        null,
+        moduleAccessMap,
+        telemetry,
+        opts.federation,
+        getMapUrl,
+      ),
           devReloadHandler(sseClients),
           staticFilesHandler(ws, !!devMode, getManifest),
-          spaFallbackHandler(getShellHtml),
+          fallbackHandler,
         ];
 
         for (const handler of handlers) {
@@ -650,6 +1026,7 @@ export async function startPlatformServer(
       contextHandler: null,
       connectionManager: null,
       setManifest,
+      setMapUrl,
       notifyReload,
       stop: () => server.stop(),
     };
@@ -683,12 +1060,27 @@ export async function startPlatformServer(
     dbAdapterFactory,
     port,
     coep,
+    // Bez allowlisty serwer odbija DOWOLNY Origin. Pole istniało w konfiguracji
+    // od zawsze, ale nikt go nie ustawiał — `ARC_CORS_ORIGINS` daje operatorowi
+    // ścieżkę, żeby ograniczyć się do originu hosta federacji.
+    corsOrigins: parseCorsOrigins(process.env.ARC_CORS_ORIGINS),
+    // PNA ma sens tylko w dev (hostowany host → localhost dewelopera). Na
+    // produkcji aplikacja nie jest zasobem sieci prywatnej.
+    allowPrivateNetwork: !!devMode,
     httpHandlers: [
       // Platform-specific handlers (checked AFTER arc handlers)
-      apiEndpointsHandler(ws, getManifest, null, moduleAccessMap, telemetry),
+      apiEndpointsHandler(
+        ws,
+        getManifest,
+        null,
+        moduleAccessMap,
+        telemetry,
+        opts.federation,
+        getMapUrl,
+      ),
       devReloadHandler(sseClients),
       staticFilesHandler(ws, !!devMode, getManifest),
-      spaFallbackHandler(getShellHtml),
+      fallbackHandler,
     ],
     onWsClose: (clientId) => cleanupClientSubs(clientId),
     telemetry,
@@ -699,6 +1091,7 @@ export async function startPlatformServer(
     contextHandler: arcServer.contextHandler,
     connectionManager: arcServer.connectionManager,
     setManifest,
+    setMapUrl,
     notifyReload,
     stop: () => {
       arcServer.stop();