@arcote.tech/arc-cli 0.4.6 → 0.4.8

package/src/platform/shared.ts

@@ -7,12 +7,13 @@ import {
   discoverPackages,
   isContextPackage,
   type BuildManifest,
+  type ModuleEntry,
   type WorkspacePackage,
 } from "../builder/module-builder";
 
 // Re-export for convenience
 export { buildPackages, buildStyles, isContextPackage };
-export type { BuildManifest, WorkspacePackage };
+export type { BuildManifest, ModuleEntry, WorkspacePackage };
 
 // ---------------------------------------------------------------------------
 // Logging
@@ -134,7 +135,7 @@ export async function buildAll(ws: WorkspaceInfo): Promise<BuildManifest> {
   }
 
   log("Building shell...");
-  await buildShell(ws.shellDir);
+  await buildShell(ws.shellDir, ws.packages);
   ok("Shell built");
 
   return manifest;
@@ -144,7 +145,30 @@ export async function buildAll(ws: WorkspaceInfo): Promise<BuildManifest> {
 // Shell builder — framework packages for import map
 // ---------------------------------------------------------------------------
 
-async function buildShell(outDir: string): Promise<void> {
+/** Collect all @arcote.tech/* peerDependencies from workspace packages. */
+export function collectArcPeerDeps(packages: WorkspacePackage[]): [string, string][] {
+  const seen = new Set<string>();
+  // Always include core framework packages
+  for (const pkg of ["@arcote.tech/arc", "@arcote.tech/arc-ds", "@arcote.tech/arc-react", "@arcote.tech/platform"]) {
+    seen.add(pkg);
+  }
+  // Scan all workspace packages for @arcote.tech/* peerDeps
+  for (const wp of packages) {
+    const peerDeps = wp.packageJson.peerDependencies ?? {};
+    for (const dep of Object.keys(peerDeps)) {
+      if (dep.startsWith("@arcote.tech/")) seen.add(dep);
+    }
+  }
+  // Convert to [shortName, fullName] entries
+  return [...seen].map((pkg) => {
+    const short = pkg === "@arcote.tech/platform"
+      ? "platform"
+      : pkg.replace("@arcote.tech/", "");
+    return [short, pkg];
+  });
+}
+
+async function buildShell(outDir: string, packages?: WorkspacePackage[]): Promise<void> {
   mkdirSync(outDir, { recursive: true });
   const tmpDir = join(outDir, "_tmp");
   mkdirSync(tmpDir, { recursive: true });
@@ -202,46 +226,53 @@ export const { createPortal, flushSync } = ReactDOM;`,
   }
 
   // Step 2: Build Arc layer (react is EXTERNAL — resolved via import map)
-  const arcEntries: [string, string][] = [
-    ["arc", "@arcote.tech/arc"],
-    ["arc-ds", "@arcote.tech/arc-ds"],
-    ["arc-react", "@arcote.tech/arc-react"],
-    ["arc-auth", "@arcote.tech/arc-auth"],
-    ["arc-utils", "@arcote.tech/arc-utils"],
-    ["arc-workspace", "@arcote.tech/arc-workspace"],
-    ["platform", "@arcote.tech/platform"],
+  // Dynamically collect only @arcote.tech/* packages actually used by workspace
+  const arcEntries = packages
+    ? collectArcPeerDeps(packages)
+    : [
+        // Fallback: core packages only (no workspace packages available)
+        ["arc", "@arcote.tech/arc"],
+        ["arc-ds", "@arcote.tech/arc-ds"],
+        ["arc-react", "@arcote.tech/arc-react"],
+        ["platform", "@arcote.tech/platform"],
+      ] as [string, string][];
+
+  const baseExternal = [
+    "react",
+    "react-dom",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime",
+    "react-dom/client",
   ];
+  const allArcPkgs = arcEntries.map(([, pkg]) => pkg);
 
-  const arcEps: string[] = [];
+  // Build each arc entry separately so it can import sibling arc packages
+  // as externals (resolved via import map) without circular self-reference.
   for (const [name, pkg] of arcEntries) {
     const f = join(tmpDir, `${name}.ts`);
     Bun.write(f, `export * from "${pkg}";\n`);
-    arcEps.push(f);
-  }
 
-  const r2 = await Bun.build({
-    entrypoints: arcEps,
-    outdir: outDir,
-    splitting: true,
-    format: "esm",
-    target: "browser",
-    naming: "[name].[ext]",
-    external: [
-      "react",
-      "react-dom",
-      "react/jsx-runtime",
-      "react/jsx-dev-runtime",
-      "react-dom/client",
-    ],
-    define: {
-      ONLY_SERVER: "false",
-      ONLY_BROWSER: "true",
-      ONLY_CLIENT: "true",
-    },
-  });
-  if (!r2.success) {
-    for (const l of r2.logs) console.error(l);
-    throw new Error("Shell Arc build failed");
+    const r2 = await Bun.build({
+      entrypoints: [f],
+      outdir: outDir,
+      format: "esm",
+      target: "browser",
+      naming: "[name].[ext]",
+      external: [
+        ...baseExternal,
+        // Other arc packages are external (not self)
+        ...allArcPkgs.filter((p) => p !== pkg),
+      ],
+      define: {
+        ONLY_SERVER: "false",
+        ONLY_BROWSER: "true",
+        ONLY_CLIENT: "true",
+      },
+    });
+    if (!r2.success) {
+      for (const l of r2.logs) console.error(l);
+      throw new Error(`Shell build failed for ${pkg}`);
+    }
   }
 
   // Clean tmp
@@ -255,9 +286,9 @@ export const { createPortal, flushSync } = ReactDOM;`,
 
 export async function loadServerContext(
   packages: WorkspacePackage[],
-): Promise<any | null> {
+): Promise<{ context: any | null; moduleAccess: Map<string, any> }> {
   const ctxPackages = packages.filter((p) => isContextPackage(p.packageJson));
-  if (ctxPackages.length === 0) return null;
+  if (ctxPackages.length === 0) return { context: null, moduleAccess: new Map() };
 
   // Set globals for server context — framework packages (arc-auth etc.)
   // use these at runtime to tree-shake browser/server code paths.
@@ -278,6 +309,7 @@ export async function loadServerContext(
   // Pre-import platform so it's cached with this absolute path
   await import(platformEntry);
 
+  // Import context packages from server dist (has server-only code paths)
   for (const ctx of ctxPackages) {
     const serverDist = join(ctx.path, "dist", "server", "main", "index.js");
     if (!existsSync(serverDist)) {
@@ -292,6 +324,20 @@ export async function loadServerContext(
     }
   }
 
-  const { getContext } = await import(platformEntry);
-  return getContext() ?? null;
+  // Import non-context packages from source to capture module().protectedBy() metadata
+  const nonCtxPackages = packages.filter((p) => !isContextPackage(p.packageJson));
+  for (const pkg of nonCtxPackages) {
+    try {
+      await import(pkg.entrypoint);
+    } catch {
+      // Non-context packages may fail on server (React components etc.) — that's OK,
+      // module().protectedBy().build() runs synchronously before any rendering
+    }
+  }
+
+  const { getContext, getAllModuleAccess } = await import(platformEntry);
+  return {
+    context: getContext() ?? null,
+    moduleAccess: getAllModuleAccess(),
+  };
 }