@arcote.tech/arc-cli 0.8.6 → 0.8.7

package/dist/index.js

@@ -31890,19 +31890,23 @@ function discoverPackages(rootDir) {
       if (pkg.name?.startsWith("@arcote.tech/"))
         continue;
       const pkgDir = join9(baseDir, entry);
-      const candidates = [
-        join9(pkgDir, "src", "index.ts"),
-        join9(pkgDir, "src", "index.tsx"),
-        join9(pkgDir, "index.ts"),
-        join9(pkgDir, "index.tsx")
+      const entryCandidates = (variant) => [
+        join9(pkgDir, "src", `index${variant}.ts`),
+        join9(pkgDir, "src", `index${variant}.tsx`),
+        join9(pkgDir, `index${variant}.ts`),
+        join9(pkgDir, `index${variant}.tsx`)
       ];
-      const entrypoint = candidates.find((c) => existsSync8(c)) ?? null;
+      const entrypoint = entryCandidates("").find((c) => existsSync8(c)) ?? null;
       if (!entrypoint)
         continue;
+      const serverEntrypoint = entryCandidates(".server").find((c) => existsSync8(c)) ?? entrypoint;
+      const clientEntrypoint = entryCandidates(".client").find((c) => existsSync8(c)) ?? entrypoint;
       results.push({
         name: pkg.name,
         path: join9(baseDir, entry),
         entrypoint,
+        serverEntrypoint,
+        clientEntrypoint,
         packageJson: pkg
       });
     }
@@ -31944,13 +31948,15 @@ function depVersionsHash(rootDir, pkg) {
 async function buildContextClient(pkg, rootDir, client, cache, noCache) {
   const unitId = `context-pkg:${pkg.name}:${client.name}`;
   const outDir = join9(pkg.path, "dist", client.name);
+  const entry = client.target === "browser" ? pkg.clientEntrypoint : pkg.entrypoint;
   const inputHash = sha256OfJson({
     src: pkgSourceHash(pkg),
     pkg: pkg.packageJson,
     deps: depVersionsHash(rootDir, pkg),
     client: client.name,
     target: client.target,
-    defines: client.defines
+    defines: client.defines,
+    entry: relative3(pkg.path, entry)
   });
   if (!noCache && isCacheHit(cache, unitId, inputHash, [join9(outDir, "main", "index.js")])) {
     console.log(`  \u2713 cached: ${pkg.name} (${client.name})`);
@@ -31961,7 +31967,7 @@ async function buildContextClient(pkg, rootDir, client, cache, noCache) {
   const allDeps = pkg.packageJson.dependencies ?? {};
   const externals = [...peerDeps, ...Object.keys(allDeps)];
   const result = await Bun.build({
-    entrypoints: [pkg.entrypoint],
+    entrypoints: [entry],
     outdir: join9(outDir, "main"),
     target: client.target,
     format: "esm",
@@ -31981,7 +31987,7 @@ async function buildContextClient(pkg, rootDir, client, cache, noCache) {
   }
   const globalsContent = Object.entries(client.defines).map(([k, v]) => `declare const ${k}: ${v};`).join(`
 `);
-  const declResult = await buildTypeDeclarations([pkg.entrypoint], outDir, dirname6(pkg.entrypoint), globalsContent);
+  const declResult = await buildTypeDeclarations([entry], outDir, dirname6(entry), globalsContent);
   const declarationErrors = !declResult.success && declResult.errors.length > 0 ? declResult.errors.map((e) => `[${pkg.name}/${client.name}] ${e}`) : [];
   const outputHash = sha256OfDir(outDir);
   updateCache(cache, unitId, inputHash, { outputHash });
@@ -32036,7 +32042,7 @@ async function buildContextPackages(rootDir, packages, cache, noCache) {
 async function buildServerApp(rootDir, serverDir, packages, cache, noCache) {
   const contexts = packages.filter((p) => isContextPackage(p.packageJson));
   mkdirSync7(serverDir, { recursive: true });
-  const srcByName = new Map(packages.map((p) => [p.name, p.entrypoint]));
+  const srcByName = new Map(packages.map((p) => [p.name, p.serverEntrypoint]));
   const externalSet = new Set(FRAMEWORK_PEERS);
   for (const p of packages) {
     for (const name of Object.keys(p.packageJson.peerDependencies ?? {})) {
@@ -32050,7 +32056,11 @@ async function buildServerApp(rootDir, serverDir, packages, cache, noCache) {
   const external = [...externalSet];
   const unitId = "server-app";
   const inputHash = sha256OfJson({
-    members: packages.map((p) => ({ name: p.name, src: pkgSourceHash(p) })).sort((a, b) => a.name.localeCompare(b.name)),
+    members: packages.map((p) => ({
+      name: p.name,
+      src: pkgSourceHash(p),
+      serverEntry: relative3(p.path, p.serverEntrypoint)
+    })).sort((a, b) => a.name.localeCompare(b.name)),
     contexts: contexts.map((p) => p.name).sort(),
     external: [...external].sort(),
     defines: SERVER_DEFINES,
@@ -32292,11 +32302,11 @@ async function buildBrowserApp(rootDir, outDir, plan, cache, noCache, i18nCollec
   const unitId = opts?.unitId ?? "browser-app";
   const allMembers = [];
   for (const m of publicMembers) {
-    allMembers.push({ name: m.pkg.name, group: "public", srcHash: pkgSourceHash(m.pkg) });
+    allMembers.push({ name: m.pkg.name, group: "public", srcHash: pkgSourceHash(m.pkg), clientEntry: relative3(m.pkg.path, m.pkg.clientEntrypoint) });
   }
   for (const g of protectedGroups) {
     for (const m of g.members) {
-      allMembers.push({ name: m.pkg.name, group: g.name, srcHash: pkgSourceHash(m.pkg) });
+      allMembers.push({ name: m.pkg.name, group: g.name, srcHash: pkgSourceHash(m.pkg), clientEntry: relative3(m.pkg.path, m.pkg.clientEntrypoint) });
     }
   }
   const inputHash = sha256OfJson({
@@ -32310,7 +32320,7 @@ async function buildBrowserApp(rootDir, outDir, plan, cache, noCache, i18nCollec
     exposeRuntime,
     minify,
     externals: federated ? [...SHELL_EXTERNALS] : [],
-    builderRev: 3
+    builderRev: 4
   });
   if (!noCache && !buildStatsEnabled() && isCacheHit(cache, unitId, inputHash)) {
     const cached = cache.units[unitId]?.outputHashes;
@@ -32363,6 +32373,12 @@ export { startApp } from "@arcote.tech/platform";
   for (const g of protectedGroups)
     for (const m of g.members)
       allMemberPkgs.set(m.pkg.name, m.pkg);
+  const clientByName = new Map;
+  for (const pkg of allMemberPkgs.values()) {
+    if (pkg.clientEntrypoint !== pkg.entrypoint) {
+      clientByName.set(pkg.name, pkg.clientEntrypoint);
+    }
+  }
   const patchedPkgJsons = [];
   for (const pkg of allMemberPkgs.values()) {
     const pkgJsonPath = join9(pkg.path, "package.json");
@@ -32389,6 +32405,7 @@ export { startApp } from "@arcote.tech/platform";
       target: "browser",
       external: federated ? [...SHELL_EXTERNALS] : [],
       plugins: [
+        ...clientByName.size > 0 ? [workspaceSourcePlugin(clientByName)] : [],
         ...federated ? [] : [singleReactPlugin(rootDir)],
         jsxDevShimPlugin(),
         nodeServerBuiltinStubPlugin(),
@@ -32780,7 +32797,7 @@ function walkTsFiles(dir, out) {
       if (entry.name === "__tests__")
         continue;
       walkTsFiles(abs, out);
-    } else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+    } else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts") && !/\.server\.tsx?$/.test(entry.name)) {
       out.push(abs);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-cli",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "CLI tool for Arc framework",
   "module": "index.ts",
   "main": "dist/index.js",
@@ -12,13 +12,13 @@
     "build": "bun build --target=bun ./src/index.ts --outdir=dist --external @arcote.tech/arc --external @arcote.tech/arc-ds --external @arcote.tech/arc-react --external @arcote.tech/platform --external @arcote.tech/arc-map --external '@opentelemetry/*' && chmod +x dist/index.js"
   },
   "dependencies": {
-    "@arcote.tech/arc": "^0.8.6",
-    "@arcote.tech/arc-ds": "^0.8.6",
-    "@arcote.tech/arc-react": "^0.8.6",
-    "@arcote.tech/arc-host": "^0.8.6",
-    "@arcote.tech/arc-adapter-db-sqlite": "^0.8.6",
-    "@arcote.tech/arc-adapter-db-postgres": "^0.8.6",
-    "@arcote.tech/arc-otel": "^0.8.6",
+    "@arcote.tech/arc": "^0.8.7",
+    "@arcote.tech/arc-ds": "^0.8.7",
+    "@arcote.tech/arc-react": "^0.8.7",
+    "@arcote.tech/arc-host": "^0.8.7",
+    "@arcote.tech/arc-adapter-db-sqlite": "^0.8.7",
+    "@arcote.tech/arc-adapter-db-postgres": "^0.8.7",
+    "@arcote.tech/arc-otel": "^0.8.7",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/api-logs": "^0.57.0",
     "@opentelemetry/core": "^1.30.0",
@@ -31,8 +31,8 @@
     "@opentelemetry/sdk-trace-base": "^1.30.0",
     "@opentelemetry/sdk-trace-node": "^1.30.0",
     "@opentelemetry/semantic-conventions": "^1.27.0",
-    "@arcote.tech/platform": "^0.8.6",
-    "@arcote.tech/arc-map": "^0.8.6",
+    "@arcote.tech/platform": "^0.8.7",
+    "@arcote.tech/arc-map": "^0.8.7",
     "@clack/prompts": "^0.9.0",
     "commander": "^11.1.0",
     "chokidar": "^3.5.3",

package/src/builder/module-builder.ts

@@ -345,7 +345,12 @@ export const SERVER_EXTERNALS_FILE = "_externals.json";
 export interface WorkspacePackage {
   name: string;
   path: string;
+  /** Base entry (src/index.ts). Fallback for both targets. */
   entrypoint: string;
+  /** src/index.server.ts if present, else `entrypoint`. Used by the SERVER bundle. */
+  serverEntrypoint: string;
+  /** src/index.client.ts if present, else `entrypoint`. Used by the CLIENT (browser) bundle. */
+  clientEntrypoint: string;
   packageJson: Record<string, any>;
 }
 
@@ -387,19 +392,30 @@ export function discoverPackages(rootDir: string): WorkspacePackage[] {
       if (pkg.name?.startsWith("@arcote.tech/")) continue;
 
       const pkgDir = join(baseDir, entry);
-      const candidates = [
-        join(pkgDir, "src", "index.ts"),
-        join(pkgDir, "src", "index.tsx"),
-        join(pkgDir, "index.ts"),
-        join(pkgDir, "index.tsx"),
+      const entryCandidates = (variant: "" | ".server" | ".client") => [
+        join(pkgDir, "src", `index${variant}.ts`),
+        join(pkgDir, "src", `index${variant}.tsx`),
+        join(pkgDir, `index${variant}.ts`),
+        join(pkgDir, `index${variant}.tsx`),
       ];
-      const entrypoint = candidates.find((c) => existsSync(c)) ?? null;
+      const entrypoint = entryCandidates("").find((c) => existsSync(c)) ?? null;
       if (!entrypoint) continue;
 
+      // Per-target entry override by file convention: index.server.ts /
+      // index.client.ts. Absent → fall back to the base entry (zero change for
+      // packages that don't opt in). Lets seeds live in index.server.ts so they
+      // never enter the client graph (see seed-guard.ts).
+      const serverEntrypoint =
+        entryCandidates(".server").find((c) => existsSync(c)) ?? entrypoint;
+      const clientEntrypoint =
+        entryCandidates(".client").find((c) => existsSync(c)) ?? entrypoint;
+
       results.push({
         name: pkg.name,
         path: join(baseDir, entry),
         entrypoint,
+        serverEntrypoint,
+        clientEntrypoint,
         packageJson: pkg,
       });
     }
@@ -480,6 +496,12 @@ async function buildContextClient(
   const unitId = `context-pkg:${pkg.name}:${client.name}`;
   const outDir = join(pkg.path, "dist", client.name);
 
+  // Per-target entry: the browser dist is built from the CLIENT entry
+  // (index.client.ts if present, else index.ts) so dist/browser reflects exactly
+  // what ships to the browser. Non-browser clients keep the base entry.
+  const entry =
+    client.target === "browser" ? pkg.clientEntrypoint : pkg.entrypoint;
+
   const inputHash = sha256OfJson({
     src: pkgSourceHash(pkg),
     pkg: pkg.packageJson,
@@ -487,6 +509,7 @@ async function buildContextClient(
     client: client.name,
     target: client.target,
     defines: client.defines,
+    entry: relative(pkg.path, entry),
   });
 
   if (!noCache && isCacheHit(cache, unitId, inputHash, [join(outDir, "main", "index.js")])) {
@@ -508,7 +531,7 @@ async function buildContextClient(
   const externals = [...peerDeps, ...Object.keys(allDeps)];
 
   const result = await Bun.build({
-    entrypoints: [pkg.entrypoint],
+    entrypoints: [entry],
     outdir: join(outDir, "main"),
     target: client.target,
     format: "esm",
@@ -535,9 +558,9 @@ async function buildContextClient(
     .join("\n");
 
   const declResult = await buildTypeDeclarations(
-    [pkg.entrypoint],
+    [entry],
     outDir,
-    dirname(pkg.entrypoint),
+    dirname(entry),
     globalsContent,
   );
 
@@ -671,7 +694,9 @@ export async function buildServerApp(
   // Every workspace package name → its SOURCE entry. Spans ALL packages, not
   // just context ones — a context package imports non-context workspace libs
   // (e.g. content-core) that must inline from source too.
-  const srcByName = new Map(packages.map((p) => [p.name, p.entrypoint]));
+  // SERVER bundle resolves every `@pkg` to its server entry (index.server.ts if
+  // present, else index.ts) via workspaceSourcePlugin — bypassing package.json.
+  const srcByName = new Map(packages.map((p) => [p.name, p.serverEntrypoint]));
 
   // External = framework peers + every non-workspace npm dep any package
   // declares. NOT bundled; resolved at runtime from /app/node_modules (the
@@ -693,7 +718,13 @@ export async function buildServerApp(
   const unitId = "server-app";
   const inputHash = sha256OfJson({
     members: packages
-      .map((p) => ({ name: p.name, src: pkgSourceHash(p) }))
+      .map((p) => ({
+        name: p.name,
+        src: pkgSourceHash(p),
+        // Which file is the server entry — invalidate if the selection changes
+        // (e.g. an index.server.ts is added/removed) even without other src edits.
+        serverEntry: relative(p.path, p.serverEntrypoint),
+      }))
       .sort((a, b) => a.name.localeCompare(b.name)),
     contexts: contexts.map((p) => p.name).sort(),
     external: [...external].sort(),
@@ -1131,13 +1162,13 @@ export async function buildBrowserApp(
 
   // Cache key spans every package's source plus the build config that
   // matters. If anything changes, full rebuild.
-  const allMembers: { name: string; group: string; srcHash: string }[] = [];
+  const allMembers: { name: string; group: string; srcHash: string; clientEntry: string }[] = [];
   for (const m of publicMembers) {
-    allMembers.push({ name: m.pkg.name, group: "public", srcHash: pkgSourceHash(m.pkg) });
+    allMembers.push({ name: m.pkg.name, group: "public", srcHash: pkgSourceHash(m.pkg), clientEntry: relative(m.pkg.path, m.pkg.clientEntrypoint) });
   }
   for (const g of protectedGroups) {
     for (const m of g.members) {
-      allMembers.push({ name: m.pkg.name, group: g.name, srcHash: pkgSourceHash(m.pkg) });
+      allMembers.push({ name: m.pkg.name, group: g.name, srcHash: pkgSourceHash(m.pkg), clientEntry: relative(m.pkg.path, m.pkg.clientEntrypoint) });
     }
   }
   const inputHash = sha256OfJson({
@@ -1155,7 +1186,8 @@ export async function buildBrowserApp(
     externals: federated ? [...SHELL_EXTERNALS] : [],
     // Podbij przy zmianie SEMANTYKI builda (pluginy/flagi), której nie widać
     // w źródłach — inaczej cache odda bundle zbudowany starą logiką.
-    builderRev: 3,
+    // 4: client-entry (index.client.ts) + workspaceClientSourcePlugin.
+    builderRev: 4,
   });
 
   // Tryb stats zawsze buduje od nowa — cache-hit pominąłby analizę i nie
@@ -1248,6 +1280,18 @@ export async function buildBrowserApp(
   for (const g of protectedGroups)
     for (const m of g.members) allMemberPkgs.set(m.pkg.name, m.pkg);
 
+  // Client-entry override: only packages that DECLARE `index.client.ts`
+  // (clientEntrypoint !== entrypoint) are redirected to their client source.
+  // Everything else — packages without a variant, framework peers, npm — misses
+  // the map and resolves natively (package.json `exports.browser`, e.g. the
+  // per-pkg dist/browser). Empty map ⇒ identical to today's behaviour.
+  const clientByName = new Map<string, string>();
+  for (const pkg of allMemberPkgs.values()) {
+    if (pkg.clientEntrypoint !== pkg.entrypoint) {
+      clientByName.set(pkg.name, pkg.clientEntrypoint);
+    }
+  }
+
   const patchedPkgJsons: { path: string; original: string }[] = [];
   for (const pkg of allMemberPkgs.values()) {
     const pkgJsonPath = join(pkg.path, "package.json");
@@ -1288,6 +1332,11 @@ export async function buildBrowserApp(
       // singletonów React/rejestru z hostem federacji.
       external: federated ? [...SHELL_EXTERNALS] : [],
       plugins: [
+        // Client-entry: `@pkg` z wariantem index.client.ts → jego source. MUSI
+        // być pierwszy (onResolve first-wins), ale mapa zawiera tylko pakiety
+        // workspace z wariantem — react/@arcote.tech/*/npm i pakiety bez wariantu
+        // miss → null → natywna rezolucja / external niżej. Zero regresji.
+        ...(clientByName.size > 0 ? [workspaceSourcePlugin(clientByName)] : []),
         // Federated: singleReactPlugin MUSI zniknąć (jego onResolve wygrałby z
         // `external` → React zbundlowany; singleton daje import mapa). Ale
         // jsxDevShimPlugin ZOSTAJE (Bun i tak emituje jsxDEV) — jego shim jest

package/src/builder/seed-guard.ts

@@ -16,9 +16,17 @@ import type { WorkspacePackage } from "./module-builder";
 // w PUBLICZNYM bundlu przeglądarki. Seedy czyta wyłącznie host (`runSeeds()`),
 // po stronie klienta nie mają żadnego zastosowania — czysty wyciek.
 //
-// Gejt wywołania to WARUNEK KONIECZNY (ten guard go egzekwuje), ale to, gdzie
-// fizycznie leży treść seeda, decyduje czy bajty realnie znikają. Zweryfikowane
-// empirycznie (migracja ndt+bmf, grep bundla klienta):
+// KANONICZNY WZORZEC (rekomendowany): trzymaj seedy w `index.server.ts` pakietu.
+// Build serwera rozwiązuje `@pkg` do `index.server.ts`, a build przeglądarki go
+// nigdy nie importuje — seedy są izolowane FIZYCZNIE (zero DCE, zero ternary,
+// zero szansy na regresję z nieczystym top-level modułu seed). Guard POMIJA pliki
+// `*.server.ts`, więc `.withSeeds(...)` nie wymaga tam gejtu. Patrz discoverPackages
+// / buildServerApp (module-builder.ts).
+//
+// ŚCIEŻKA LEGACY (pliki współdzielone klient+serwer): gejt wywołania to WARUNEK
+// KONIECZNY (ten guard go egzekwuje), ale to, gdzie fizycznie leży treść seeda,
+// decyduje czy bajty realnie znikają. Zweryfikowane empirycznie (migracja ndt+bmf,
+// grep bundla klienta):
 //
 //   // mały seed — inline w gejtowanym literale (ZAWSZE działa: constant-fold):
 //   .seedWith(ONLY_SERVER ? [ { /* wiersze */ } ] : [])
@@ -63,7 +71,16 @@ function walkTsFiles(dir: string, out: string[]): void {
     if (entry.isDirectory()) {
       if (entry.name === "__tests__") continue;
       walkTsFiles(abs, out);
-    } else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+    } else if (
+      entry.isFile() &&
+      /\.(ts|tsx)$/.test(entry.name) &&
+      !entry.name.endsWith(".d.ts") &&
+      // `*.server.ts(x)` (w tym index.server.ts) NIE trafiają do bundla klienta —
+      // build serwera rozwiązuje `@pkg` do index.server.ts, a build przeglądarki
+      // nigdy go nie importuje. Seedy w tych plikach są izolowane fizycznie, więc
+      // `.withSeeds(...)` nie wymaga tam gejtu `ONLY_SERVER`.
+      !/\.server\.tsx?$/.test(entry.name)
+    ) {
       out.push(abs);
     }
   }