@arcote.tech/arc-cli 0.8.2 → 0.8.4

package/src/deploy/remote-state.ts

@@ -24,6 +24,15 @@ export type RemoteState =
 export interface RemoteStateMarker {
   cliVersion: string;
   configHash: string;
+  /**
+   * sha256 wyrenderowanych artefaktów stacku (Caddyfile + docker-compose).
+   * Wykrywa zmianę GENERATORA w obrębie tej samej wersji CLI — bez tego
+   * republish tej samej wersji z poprawionym Caddyfile (np. dodane `encode`)
+   * nie odświeżał configu na hoście (needUpStack patrzył tylko na cliVersion
+   * i configHash). Opcjonalny: starsze markery go nie mają → traktowane jako
+   * zmiana (wymusza jednorazowy upStack, po którym marker dostaje hash).
+   */
+  artifactsHash?: string;
   updatedAt: string;
 }
 

package/src/index.ts

@@ -52,8 +52,12 @@ platform
   .command("build")
   .description("Build platform for production")
   .option("--no-cache", "Force full rebuild")
-  .action((opts: { cache?: boolean }) =>
-    platformBuild({ noCache: opts.cache === false }),
+  .option(
+    "--stats",
+    "Wypisz rozbicie chunków na biblioteki (per-wejście raw/gzip + najcięższe liby, ext/wewn). Wymusza pełny build.",
+  )
+  .action((opts: { cache?: boolean; stats?: boolean }) =>
+    platformBuild({ noCache: opts.cache === false, stats: opts.stats }),
   );
 
 platform

package/src/platform/shared.ts

@@ -25,7 +25,11 @@ import {
 import { extractAccessMap } from "../builder/access-extractor";
 import { buildPeerShell, type PeerShellResult } from "../builder/peer-shell";
 import type { FederationConfig } from "@arcote.tech/platform";
-import { assertOneModulePerPackage, planChunks } from "../builder/chunk-planner";
+import {
+  assertOneModulePerPackage,
+  packageDeclaresModule,
+  planChunks,
+} from "../builder/chunk-planner";
 import { collectFrameworkDeps } from "../builder/dependency-collector";
 import {
   mtimeOf,
@@ -144,6 +148,11 @@ export function resolveWorkspace(): WorkspaceInfo {
 
 export interface BuildOptions {
   noCache?: boolean;
+  /**
+   * Minifikacja bundli przeglądarki (domyślnie true — build/deploy).
+   * Dev watcher podaje false: czytelny kod w devtools, szybszy rebuild.
+   */
+  minify?: boolean;
 }
 
 /**
@@ -157,6 +166,7 @@ export async function buildAll(
 ): Promise<BuildManifest> {
   const cache = loadBuildCache(ws.arcDir);
   const noCache = opts.noCache ?? false;
+  const minify = opts.minify ?? true;
   const themePath = ws.rootPkg.arc?.theme as string | undefined;
   const federation = getFederationConfig(ws);
 
@@ -201,13 +211,20 @@ export async function buildAll(
   const moduleNameOf = (name: string) => name.split("/").pop() ?? name;
   const exposureOf = (pkgName: string): "local" | "external" | "both" =>
     accessMap.exposure[moduleNameOf(pkgName)]?.exposure ?? "local";
+  // Tylko pakiety DEKLARUJĄCE moduł Arc są członami wchodzącymi do initial/grup.
+  // Czyste biblioteki (np. @ndt/email — szablony maili) NIE mogą być tu, bo
+  // initial robiłoby `import "@pkg"` i przy `sideEffects:true` (patch buildu)
+  // wciągałoby całe ich drzewo zależności do pierwszego wczytania. Taka libka
+  // trafia do bundla NORMALNIE — dopiero gdy realnie zaimportuje ją moduł
+  // (wtedy podlega tree-shakingowi / lazy-split).
+  const modulePackages = ws.packages.filter(packageDeclaresModule);
   // Normalna platforma: moduły local/both (external-only ukryte w macierzystej
   // platformie). Host bierze wszystko (nie ukrywa niczego przed sobą).
   const localPackages = isHost
-    ? ws.packages
-    : ws.packages.filter((p) => exposureOf(p.name) !== "external");
+    ? modulePackages
+    : modulePackages.filter((p) => exposureOf(p.name) !== "external");
   // Build federowany: moduły external/both → browser-fed/.
-  const fedPackages = ws.packages.filter((p) =>
+  const fedPackages = modulePackages.filter((p) =>
     ["external", "both"].includes(exposureOf(p.name)),
   );
   const hasFederatedModules = fedPackages.length > 0;
@@ -238,31 +255,47 @@ export async function buildAll(
   // zawsze external peers) + peer-shell.
   const i18nCollector = new Map<string, Set<string>>();
 
-  const [browserResult, , , , shellResult, fedResult] = await Promise.all([
+  // Dwa buildy przeglądarkowe (bundled + federated) biegną SZEREGOWO, nie w
+  // Promise.all: oba mutują TE SAME package.json (patch sideEffects na czas
+  // builda) — przy równoległym biegu `finally` szybszego builda przywraca
+  // oryginał, zanim wolniejszy skończy bundlować, i tree-shaking wolniejszego
+  // biegnie na złych metadanych. Koszt: +czas builda fed; zysk: deterministyka.
+  const browserSequence = (async () => {
     // HOST buduje się BUNDLED (React inline, eager — bez lazy-race), a initial
     // eksponuje runtime na globalThis; gościa obsłuży peer-shell (globalThis).
-    buildBrowserApp(ws.rootDir, ws.browserDir, plan, cache, noCache, i18nCollector, {
-      federated: false,
-      exposeRuntime: isHost,
-    }),
-    buildStyles(ws.rootDir, ws.arcDir, ws.packages, themePath, cache, noCache),
-    copyBrowserAssets(ws, cache, noCache),
-    buildTranslations(ws.rootDir, ws.arcDir, cache, noCache),
-    needsPeerShell
-      ? buildPeerShell(ws.rootDir, join(ws.arcDir, "shell"), cache, noCache)
-      : Promise.resolve(undefined),
-    fedPlan
-      ? buildBrowserApp(
+    const bundled = await buildBrowserApp(
+      ws.rootDir,
+      ws.browserDir,
+      plan,
+      cache,
+      noCache,
+      i18nCollector,
+      { federated: false, exposeRuntime: isHost, minify },
+    );
+    const fed = fedPlan
+      ? await buildBrowserApp(
           ws.rootDir,
           join(ws.arcDir, "browser-fed"),
           fedPlan,
           cache,
           noCache,
           i18nCollector,
-          { federated: true, unitId: "browser-app-fed" },
+          { federated: true, unitId: "browser-app-fed", minify },
         )
-      : Promise.resolve(undefined),
-  ]);
+      : undefined;
+    return { bundled, fed };
+  })();
+
+  const [{ bundled: browserResult, fed: fedResult }, , , , shellResult] =
+    await Promise.all([
+      browserSequence,
+      buildStyles(ws.rootDir, ws.arcDir, ws.packages, themePath, cache, noCache),
+      copyBrowserAssets(ws, cache, noCache),
+      buildTranslations(ws.rootDir, ws.arcDir, cache, noCache),
+      needsPeerShell
+        ? buildPeerShell(ws.rootDir, join(ws.arcDir, "shell"), cache, noCache)
+        : Promise.resolve(undefined),
+    ]);
 
   // Finalize i18n catalogs once after all chunks + initial bundle collected.
   const { finalizeTranslations } = await import("../i18n");
@@ -493,7 +526,18 @@ async function copyBrowserAssets(
 
 export async function loadServerContext(
   ws: WorkspaceInfo,
-): Promise<{ context: any | null; moduleAccess: Map<string, any> }> {
+): Promise<{
+  context: any | null;
+  moduleAccess: Map<string, any>;
+  /**
+   * Set gdy import bundla serwerowego RZUCIŁ (np. fail-fast na brakującym env).
+   * Kontekst jest wtedy CZĘŚCIOWY — część modułów się nie zarejestrowała, więc
+   * ich query rzucają `Element not found`. Caller uruchamiający serwer MUSI to
+   * potraktować jako twardy błąd startu (patrz startup.ts), inaczej aplikacja
+   * wstaje połowiczna i cicho. Build/access-extractor może to zignorować.
+   */
+  serverError?: unknown;
+}> {
   // Set globals for server context — framework packages (arc-auth etc.)
   // use these at runtime to tree-shake browser/server code paths.
   (globalThis as any).ONLY_SERVER = true;
@@ -519,15 +563,18 @@ export async function loadServerContext(
     // No build yet (or a static-only workspace) — nothing to register.
     return { context: null, moduleAccess: new Map() };
   }
+  let serverError: unknown;
   try {
     await import(serverEntry);
   } catch (e) {
     err(`Failed to load server bundle ${SERVER_ENTRY_FILE}: ${e}`);
+    serverError = e;
   }
 
   const { getContext, getAllModuleAccess } = await import(platformEntry);
   return {
     context: getContext() ?? null,
     moduleAccess: getAllModuleAccess(),
+    serverError,
   };
 }

package/src/platform/startup.ts

@@ -60,7 +60,7 @@ export async function startPlatform(
   // missing manifest is a hard error.
   let manifest: BuildManifest;
   if (devMode) {
-    manifest = await buildAll(ws);
+    manifest = await buildAll(ws, { minify: false });
   } else {
     const manifestPath = join(ws.arcDir, "manifest.json");
     if (!existsSync(manifestPath)) {
@@ -88,7 +88,21 @@ export async function startPlatform(
   // imports the combined server bundle at .arc/platform/server/_server.js
   // (produced by the buildServerApp step in buildAll).
   log("Loading server context...");
-  const { context, moduleAccess } = await loadServerContext(ws);
+  const { context, moduleAccess, serverError } = await loadServerContext(ws);
+  // TWARDY STOP: import bundla serwerowego rzucił (np. fail-fast na brakującym
+  // env). Kontekst jest wtedy CZĘŚCIOWY — część agregatów się nie
+  // zarejestrowała, więc ich query rzucałyby `Element not found`, a aplikacja
+  // wyglądałaby na działającą (login OK), tyle że połowiczną. Przerywamy start
+  // GŁOŚNO, zamiast wstawać po cichu — to była realna produkcyjna pułapka.
+  if (serverError) {
+    err(
+      "Serwer NIE wstanie: moduł serwerowy nie załadował się (błąd wyżej). " +
+        "Częściowy kontekst = połowiczna aplikacja (query rzucają " +
+        "'Element not found'). Napraw przyczynę (np. brakujące zmienne " +
+        "środowiskowe) i wystartuj ponownie.",
+    );
+    process.exit(1);
+  }
   if (context) {
     ok("Context loaded");
   } else {
@@ -381,7 +395,7 @@ function attachDevWatcher(
       isRebuilding = true;
       log("Rebuilding...");
       try {
-        const next = await buildAll(ws);
+        const next = await buildAll(ws, { minify: false });
         platform.setManifest(next);
         platform.notifyReload(next);
         onReload?.();