@ws-test-realm/admin-kit 0.1.14 → 0.2.1-ng16

package/lib/build-modules.js

@@ -16,8 +16,8 @@ function loadOrder({ workspaceDir, restrictTo, withDeps = false }) {
 
 // A project declares itself a library (not a federated remote) by setting
 // `wsmodules.kind = "library"` in its own package.json. Default kind is
-// "remote": build/pack/deploy all run. Libraries are still built (their dist
-// is consumed by sibling projects) but skip pack/deploy.
+// "remote": build/deploy both run. Libraries are still built (their dist
+// is consumed by sibling projects) but skip deploy.
 function isLibrary(workspaceDir, name) {
   const pkgPath = path.join(workspaceDir, "projects", name, "package.json");
   if (!fs.existsSync(pkgPath)) return false;
@@ -53,31 +53,27 @@ function buildLibs({ workspaceDir, restrictTo = [], withDeps = false }) {
     });
   }
 
-  console.log(`\nBuilt ${order.length} lib(s).`);
+  console.log(`\nBuilt ${order.length} project(s).`);
   return { order };
 }
 
+// Under native-federation the artifact (`remoteEntry.json` + chunks) is
+// produced directly by `ng build` via the @angular-architects/native-federation
+// builder. There is no separate webpack pack step. Kept as a no-op so the
+// `npm run wire = ws-modules --build --pack --deploy` convention keeps
+// working without churn.
 function packRemotes({ workspaceDir, restrictTo = [], withDeps = false }) {
   const { order } = loadOrder({ workspaceDir, restrictTo, withDeps });
   const { remotes, libraries } = partitionByKind(workspaceDir, order);
 
-  console.log(`\n=== Pack order ===`);
-  remotes.forEach((n, i) => console.log(`  ${i + 1}. ${n}`));
+  console.log(`\n=== Pack (no-op under native-federation) ===`);
+  remotes.forEach((n, i) => console.log(`  ${i + 1}. ${n}  (artifact already produced by ng build)`));
   if (libraries.length) {
     console.log(
       `  (skipping libraries: ${libraries.join(", ")} — wsmodules.kind=library)`
     );
   }
 
-  for (const name of remotes) {
-    console.log(`\n=== ws-pack-remote ${name} ===`);
-    execSync(
-      `ws-pack-remote --project projects/${name} --workspace .`,
-      { cwd: workspaceDir, stdio: "inherit" }
-    );
-  }
-
-  console.log(`\nPacked ${remotes.length} remote(s).`);
   return { order: remotes, libraries };
 }
 

package/lib/cli-args.js

@@ -1,5 +1,5 @@
-// Shared CLI arg parsing + selection-mode resolution for ws-build-libs,
-// ws-pack-remotes, ws-deploy-remotes.
+// Shared CLI arg parsing + selection-mode resolution for the ws-modules
+// driver (build + deploy across an admin-modules workspace).
 //
 // Selection modes:
 //   inert  — no positional args; print usage, do nothing

package/lib/deploy-remotes.js

@@ -4,27 +4,47 @@ const { packIntoJar } = require("./pack-into-jar");
 const { loadOrder, partitionByKind } = require("./build-modules");
 const { findMatches } = require("./jar-glob");
 const { loadDeployContext, resolveTarget } = require("./target-resolution");
-const { promotePeerDeps, syncFederationWorkspace } = require("./federation-peers");
+const { emitDescriptor } = require("./emit-descriptor");
+const { readIdentity } = require("./identity");
+
+// Resolve the build output for a native-federation remote. The Angular
+// application builder (esbuild) emits to `dist/<id>/browser/` by default;
+// older builder configurations may still write to `dist/<id>/`. Probe both
+// and return whichever contains `remoteEntry.json`.
+function resolveBuildOutput(workspaceDir, id) {
+  const candidates = [
+    path.join(workspaceDir, "dist", id, "browser"),
+    path.join(workspaceDir, "dist", id),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(path.join(c, "remoteEntry.json"))) return c;
+  }
+  throw new Error(
+    `Native-federation artifact not found for '${id}'. Expected remoteEntry.json under one of: ${candidates.join(
+      ", "
+    )}. Did the build step run?`
+  );
+}
 
-function copyTypes(distLib, hostFederationDir) {
-  if (fs.existsSync(hostFederationDir)) {
-    fs.rmSync(hostFederationDir, { recursive: true, force: true });
+// Stage the build output + descriptor into a deploy-ready tree:
+//   <stagingDir>/<id>/{federation.json, remote/<all chunks + remoteEntry.json>}
+// `remote/` mirrors the path the federation controller serves contributions
+// under, so packing-into-jar and ext-copy are uniform.
+function stageContribution({ workspaceDir, id, remoteName, hostId }) {
+  const buildDir = resolveBuildOutput(workspaceDir, id);
+  const stagingRoot = path.join(workspaceDir, "dist", "admin-remotes");
+  const idDir = path.join(stagingRoot, id);
+  if (fs.existsSync(idDir)) {
+    fs.rmSync(idDir, { recursive: true, force: true });
   }
-  fs.mkdirSync(hostFederationDir, { recursive: true });
-  fs.cpSync(distLib, hostFederationDir, { recursive: true });
-  // Promote peerDependencies → dependencies in the staged package.json so
-  // npm's workspace install actually installs them. The producer's source
-  // package.json is untouched; this only affects the host-staged copy.
-  // syncFederationWorkspace runs once at the end of the deploy loop and
-  // re-establishes <federationDir>/node_modules from scratch, so we don't
-  // need to preserve any prior node_modules under <id>/.
-  promotePeerDeps(hostFederationDir);
+  const remoteDir = path.join(idDir, "remote");
+  fs.mkdirSync(remoteDir, { recursive: true });
+  fs.cpSync(buildDir, remoteDir, { recursive: true });
+  emitDescriptor({ outDir: stagingRoot, id, hostId, remoteName });
+  return idDir;
 }
 
-// Copy the federation artifact (dist/admin-remotes/<id>/) to the ext target
-// dir (replace-existing semantics). Also warn if a same-id-named jar exists
-// in the modules folder — possible name-collision abuse signal.
-function deployExt({ workspaceDir, id, modulesDir, extDir }) {
+function deployExt({ workspaceDir, id, modulesDir, extDir, stagedDir }) {
   const collisions = findMatches(modulesDir, `${id}-*.jar`);
   if (collisions.length) {
     const list = collisions.map((c) => path.join(modulesDir, c)).join(", ");
@@ -32,17 +52,11 @@ function deployExt({ workspaceDir, id, modulesDir, extDir }) {
       `\x1b[33mWarning:\x1b[0m a jar matching '${id}-*.jar' exists at ${list}; this project is targeting ext, but the name collision may indicate abuse.`
     );
   }
-  const srcDir = path.join(workspaceDir, "dist", "admin-remotes", id);
-  if (!fs.existsSync(srcDir)) {
-    throw new Error(
-      `Federation artifact missing: ${srcDir}. Run \`pack:remote\` first.`
-    );
-  }
   if (fs.existsSync(extDir)) {
     fs.rmSync(extDir, { recursive: true, force: true });
   }
   fs.mkdirSync(extDir, { recursive: true });
-  fs.cpSync(srcDir, extDir, { recursive: true });
+  fs.cpSync(stagedDir, extDir, { recursive: true });
   let fileCount = 0;
   const walk = (d) => {
     for (const e of fs.readdirSync(d, { withFileTypes: true })) {
@@ -64,19 +78,13 @@ function deployOne({
   modulesDir,
   wsconfig,
 }) {
-  const distRemoteDir = path.join(workspaceDir, "dist", "admin-remotes", id);
-  const distLibDir = path.join(workspaceDir, "dist", id);
-
-  if (!fs.existsSync(distRemoteDir)) {
-    throw new Error(
-      `Federation artifact missing: ${distRemoteDir}. Run \`pack:remote\` first.`
-    );
-  }
-  if (!fs.existsSync(distLibDir)) {
-    throw new Error(`Lib dist missing: ${distLibDir}. Run \`build\` first.`);
-  }
-
-  const hostFederationDir = path.join(adminDir, ".federation", id);
+  const identity = readIdentity(workspaceDir, id);
+  const stagedDir = stageContribution({
+    workspaceDir,
+    id,
+    remoteName: identity.remoteName,
+    hostId: identity.hostId,
+  });
 
   const target = resolveTarget({
     workspaceDir,
@@ -86,33 +94,29 @@ function deployOne({
     modulesFolder,
   });
 
-  let artifactReport;
   if (target.kind === "jar") {
     const packResult = packIntoJar({
       jarPath: target.jarPath,
-      sourceDir: distRemoteDir,
+      sourceDir: stagedDir,
       id,
     });
-    artifactReport = {
+    return {
       kind: "jar",
       jarPath: target.jarPath,
       pomPath: target.pomPath,
       artifactId: target.artifactId,
       ...packResult,
     };
-  } else {
-    const extResult = deployExt({
-      workspaceDir,
-      id,
-      modulesDir,
-      extDir: target.extDir,
-    });
-    artifactReport = { kind: "ext", ...extResult };
   }
 
-  copyTypes(distLibDir, hostFederationDir);
-
-  return { ...artifactReport, hostFederationDir };
+  const extResult = deployExt({
+    workspaceDir,
+    id,
+    modulesDir,
+    extDir: target.extDir,
+    stagedDir,
+  });
+  return { kind: "ext", ...extResult };
 }
 
 function deployRemotes({ workspaceDir, restrictTo = [], withDeps = false }) {
@@ -157,26 +161,11 @@ function deployRemotes({ workspaceDir, restrictTo = [], withDeps = false }) {
       console.log(`  ext dir:       ${r.extDir}`);
       console.log(`  copied files:  ${r.copiedFiles}`);
     }
-    console.log(`  host types:    ${r.hostFederationDir}`);
     results.push({ id, ...r });
   }
 
   console.log(`\nDeployed ${results.length} module(s).`);
 
-  // Now that the .federation/<id>/ dirs are fresh, run a single workspace
-  // install at .federation/ to populate node_modules. npm hoists shared
-  // versions to .federation/node_modules/ and only nests on per-lib version
-  // conflicts. Consumers' TypeScript walks up from .federation/<id>/ and
-  // resolves transitive types without consumer-side dep management.
-  try {
-    syncFederationWorkspace(ctx.adminDir, workspaceDir);
-  } catch (e) {
-    console.warn(
-      `\x1b[33mWarning:\x1b[0m federation peer install failed: ${e.message}`
-    );
-    console.warn(`  Consumer workspaces may fail to type-check federated libs.`);
-  }
-
   return { results };
 }
 

package/lib/emit-descriptor.js

@@ -3,26 +3,20 @@ const path = require("path");
 
 // Write <out>/<id>/federation.json — the descriptor the admin federation
 // controller reads (both jar-side and ext-side).
-function emitDescriptor({
-  outDir,
-  id,
-  hostId,
-  remoteName,
-  exposes,
-  displayName,
-}) {
+//
+// Under native-federation, the only field the fiddle controller needs from
+// each descriptor to build the manifest is `remoteName`. The host loads the
+// remote by fetching `remoteEntry.json` at the asset URL the controller
+// returns; no separate `exposedModule` lookup is required because the
+// import-map carries the entry mapping directly.
+function emitDescriptor({ outDir, id, hostId, remoteName }) {
   const dir = path.join(outDir, id);
   fs.mkdirSync(dir, { recursive: true });
   const file = path.join(dir, "federation.json");
   const descriptor = {
     hostId,
     contributionId: id,
-    manifestEntry: {
-      id,
-      name: displayName,
-      remoteName,
-      exposedModule: exposes,
-    },
+    manifestEntry: { remoteName },
   };
   fs.writeFileSync(file, JSON.stringify(descriptor, null, 2) + "\n", "utf8");
   return file;

package/lib/generate-module.js

@@ -51,26 +51,36 @@ function copyAndSubstitute(src, dest, tokens) {
   }
 }
 
+// Register the project as a native-federation application in angular.json.
+// `build` is the @angular-architects/native-federation:build target, which
+// post-processes the underlying esbuild app target (`esbuild`) to emit
+// remoteEntry.json + shared/exposed chunk bundles next to the application
+// bundle. Names match the federation.config.js `name` derivation.
 function registerInAngularJson(workspaceDir, name) {
   const angularJsonPath = path.join(workspaceDir, "angular.json");
   const angular = JSON.parse(fs.readFileSync(angularJsonPath, "utf8"));
   angular.projects = angular.projects || {};
   angular.projects[name] = {
-    projectType: "library",
+    projectType: "application",
+    schematics: {},
     root: `projects/${name}`,
     sourceRoot: `projects/${name}/src`,
     prefix: "ws",
     architect: {
       build: {
-        builder: "@angular-devkit/build-angular:ng-packagr",
-        options: { project: `projects/${name}/ng-package.json` },
-        configurations: {
-          production: {
-            tsConfig: `projects/${name}/tsconfig.lib.prod.json`,
-          },
-          development: { tsConfig: `projects/${name}/tsconfig.lib.json` },
+        builder: "@angular-architects/native-federation:build",
+        options: { target: `${name}:esbuild` },
+      },
+      esbuild: {
+        builder: "@angular-devkit/build-angular:application",
+        options: {
+          outputPath: `dist/${name}`,
+          index: `projects/${name}/src/index.html`,
+          browser: `projects/${name}/src/main.ts`,
+          polyfills: [`projects/${name}/src/polyfills.ts`],
+          tsConfig: `projects/${name}/tsconfig.app.json`,
+          assets: [`projects/${name}/src/assets`],
         },
-        defaultConfiguration: "production",
       },
     },
   };

package/lib/identity.js

@@ -46,4 +46,22 @@ function resolveIdentity(args) {
   };
 }
 
-module.exports = { resolveIdentity, camelCase };
+// Lightweight identity lookup used by deploy-remotes.js. Derives the
+// federated remote name from the project directory name (camelCased) and
+// picks up the host id from the workspace's wsconfig.json (default "admin").
+// The project's own `federation.config.js` declares the same `name` value;
+// keeping the derivation here means deploy doesn't have to evaluate that
+// config file at deploy time.
+function readIdentity(workspaceDir, id) {
+  let hostId = "admin";
+  try {
+    const wsconfigPath = path.join(workspaceDir, "wsconfig.json");
+    if (fs.existsSync(wsconfigPath)) {
+      const ws = JSON.parse(fs.readFileSync(wsconfigPath, "utf8"));
+      if (ws.hostId) hostId = ws.hostId;
+    }
+  } catch {}
+  return { id, hostId, remoteName: camelCase(id) };
+}
+
+module.exports = { resolveIdentity, camelCase, readIdentity };

package/lib/pack-into-jar.js

@@ -22,9 +22,9 @@ function walk(dir, base = dir) {
 // Repack a jar to carry a federated remote contribution under
 // META-INF/federation/<id>/. Drops any pre-existing entries under that
 // prefix (so re-deploys are clean), then adds every file under sourceDir
-// at <prefix>/<relpath>. sourceDir is expected to be the
-// dist/admin-remotes/<id>/ tree (which already contains both
-// federation.json and remote/* per ws-pack-remote's emit).
+// at <prefix>/<relpath>. sourceDir is expected to be the staged
+// dist/admin-remotes/<id>/ tree (federation.json + remote/* with the
+// native-federation `remoteEntry.json` + chunks).
 function packIntoJar({ jarPath, sourceDir, id }) {
   if (!fs.existsSync(jarPath)) {
     throw new Error(`Jar not found: ${jarPath}`);

package/lib/purge-remotes.js

@@ -3,7 +3,6 @@ const path = require("path");
 const { purgeJar } = require("./purge-jar");
 const { loadOrder, partitionByKind } = require("./build-modules");
 const { loadDeployContext, resolveTarget } = require("./target-resolution");
-const { syncFederationWorkspace } = require("./federation-peers");
 
 // Per-remote purge action. Returns a structured action record.
 function purgeOne({ workspaceDir, id, ctx }) {
@@ -122,19 +121,6 @@ function purgeRemotes({
 
   reportActions({ actions, skipped, errors });
 
-  // Removed federation type dirs ⇒ workspaces list is stale; resync so
-  // the remaining libs stay correctly installed (and orphaned ones stop
-  // claiming workspace slots).
-  if (actions.some((a) => a.typesRemoved)) {
-    try {
-      syncFederationWorkspace(ctx.adminDir, workspaceDir);
-    } catch (e) {
-      console.warn(
-        `\x1b[33mWarning:\x1b[0m federation peer resync failed: ${e.message}`
-      );
-    }
-  }
-
   return { actions, skipped, errors };
 }
 

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@ws-test-realm/admin-kit",
-  "version": "0.1.14",
-  "description": "Workflow CLI + scaffolding for Wiresphere admin-modules workspaces. Ships `ws-init-workspace` (init/merge into a project, stamps @wiresphere/shared's `getOverrides()` into the workspace's npm overrides block), `ws-modules` (build/pack/deploy driver), `ws-generate-module`/`ws-drop-module`, `ws-wire-host`, `ws-wire-pom`, `ws-sync-paths`, and `ws-pack-remote`. Depends on @wiresphere/devkit (toolchain BOM, peerDeps); pairs with @wiresphere/shared (runtime BOM + MF share map + overrides manifest). Requires npm 9+ for overrides + peerDep resolution to coexist cleanly.",
+  "version": "0.2.1-ng16",
+  "description": "Workflow CLI + scaffolding for Wiresphere admin-modules workspaces (Angular 16 + native-federation line). Ships `ws-init-workspace`, `ws-modules` (build+deploy driver), `ws-generate-module`/`ws-drop-module`, `ws-wire-host`, `ws-wire-pom`, `ws-sync-paths`, and `ws-purge`. Depends on @ws-test-realm/devkit (toolchain BOM) + @ws-test-realm/shared (runtime BOM + native-federation share map).",
   "license": "Artistic-2.0",
   "publishConfig": {
     "access": "public"
   },
   "bin": {
-    "ws-pack-remote": "./bin/ws-pack-remote.js",
     "ws-init-workspace": "./bin/ws-init-workspace.js",
     "ws-wire-host": "./bin/ws-wire-host.js",
     "ws-wire-pom": "./bin/ws-wire-pom.js",
@@ -21,16 +20,15 @@
   "files": [
     "bin",
     "lib",
-    "hooks",
     "template",
     "template-module",
     "README.md"
   ],
   "dependencies": {
-    "@ws-test-realm/devkit": "^0.3.0",
-    "@ws-test-realm/shared": "^0.3.0",
+    "@angular-architects/native-federation": "^16.0.0",
+    "@ws-test-realm/devkit": "file:/Users/ph/projects/ws-admin-aux/devkit",
+    "@ws-test-realm/shared": "file:/Users/ph/projects/ws-admin-aux/shared",
     "adm-zip": "^0.5.10",
-    "fast-xml-parser": "^4.3.0",
-    "tsconfig-paths-webpack-plugin": "^4.1.0"
+    "fast-xml-parser": "^4.3.0"
   }
 }

package/template/package.json

@@ -16,12 +16,12 @@
 		"wire": "ws-modules --build --pack --deploy"
 	},
 	"prettier": "@ws-test-realm/devkit/prettier.config.js",
-	"husky": {
-		"hooks": {
-			"pre-commit": "ws-pre-commit"
-		}
-	},
 	"dependencies": {
-		"@ws-test-realm/shared": "^0.3.0"
+		"@ws-test-realm/shared": "^0.4.0-ng16",
+		"@ws-test-realm/ws-core": "^0.1.0-ng16"
+	},
+	"devDependencies": {
+		"@ws-test-realm/admin-kit": "^0.2.0-ng16",
+		"@ws-test-realm/devkit": "^0.4.0-ng16"
 	}
 }

package/template/tsconfig.json

@@ -1,5 +1,5 @@
 {
-	"extends": "./tsconfig.federation.json",
+	"extends": "@ws-test-realm/devkit/tsconfig.base.json",
 	"compilerOptions": {
 		"baseUrl": "./",
 		"outDir": "./dist/out-tsc"

package/template-module/federation.config.js

@@ -0,0 +1,11 @@
+const { withNativeFederation } = require('@angular-architects/native-federation/config');
+const { sharedDescriptors } = require('@ws-test-realm/shared');
+
+module.exports = withNativeFederation({
+	name: '__camelName__Module',
+	exposes: {
+		'./Module': './src/public-api.ts',
+	},
+	shared: sharedDescriptors(),
+	skip: ['rxjs/ajax', 'rxjs/fetch', 'rxjs/testing', 'rxjs/webSocket'],
+});

package/template-module/package.json

@@ -2,13 +2,16 @@
 	"name": "__name__",
 	"version": "0.0.1",
 	"peerDependencies": {
-		"@angular/common": "12.2.0",
-		"@angular/core": "12.2.0",
-		"@angular/forms": "12.2.0",
-		"@angular/router": "12.2.0",
-		"rxjs": "6.5.3"
+		"@angular/common": "16.2.12",
+		"@angular/core": "16.2.12",
+		"@angular/forms": "16.2.12",
+		"@angular/router": "16.2.12",
+		"rxjs": "~7.8.0"
 	},
 	"dependencies": {
-		"tslib": "^2.3.0"
+		"tslib": "^2.5.0"
+	},
+	"wsmodules": {
+		"target": "jar"
 	}
 }

package/template-module/src/index.html

@@ -0,0 +1,8 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<title>__name__ federated remote</title>
+	</head>
+	<body></body>
+</html>

package/template-module/src/main.ts

@@ -0,0 +1,6 @@
+// Federated remote entry — this remote is consumed by the host via
+// `loadRemoteModule('__camelName__Module', './Module')`. main.ts exists
+// because the native-federation builder wraps an `application` builder
+// target, which requires an entry. The actual exposed surface is
+// `./src/public-api.ts` (see federation.config.js).
+export {};

package/template-module/src/polyfills.ts

@@ -0,0 +1 @@
+import 'zone.js';

package/template-module/tsconfig.app.json

@@ -0,0 +1,9 @@
+{
+	"extends": "../../tsconfig.json",
+	"compilerOptions": {
+		"outDir": "../../out-tsc/app",
+		"types": []
+	},
+	"files": ["src/main.ts", "src/polyfills.ts"],
+	"include": ["src/**/*.d.ts"]
+}

package/bin/ws-pack-remote.js

@@ -1,196 +0,0 @@
-#!/usr/bin/env node
-// ws-pack-remote — pack a built lib's dist into a deploy-ready
-// federated remote artifact. See README.md for usage.
-
-const fs = require("fs");
-const path = require("path");
-const Module = require("module");
-
-const { resolveIdentity } = require("../lib/identity");
-const { discoverWorkspaceAliases } = require("../lib/alias-discovery");
-const { writeSyntheticEntry, cleanup } = require("../lib/synthetic-entry");
-const { buildSharedMap } = require("../lib/shared-deps");
-const { buildWebpackConfig } = require("../lib/webpack-factory");
-const { emitDescriptor } = require("../lib/emit-descriptor");
-
-function parseArgs(argv) {
-  const aliases = {
-    project: "project",
-    workspace: "workspace",
-    out: "out",
-    id: "id",
-    host: "host",
-    "remote-name": "remoteName",
-    exposes: "exposes",
-    "display-name": "displayName",
-    config: "config",
-  };
-  const args = {};
-  for (let i = 2; i < argv.length; i++) {
-    const a = argv[i];
-    if (!a.startsWith("--")) continue;
-    const key = a.slice(2);
-    const mapped = aliases[key];
-    if (!mapped) {
-      console.error(`Unknown flag: --${key}`);
-      process.exit(1);
-    }
-    const val = argv[i + 1];
-    if (val === undefined || val.startsWith("--")) {
-      args[mapped] = true;
-    } else {
-      args[mapped] = val;
-      i++;
-    }
-  }
-  return args;
-}
-
-function require_(args, key) {
-  if (!args[key]) {
-    console.error(`Missing required flag: --${kebab(key)}`);
-    process.exit(1);
-  }
-  return args[key];
-}
-
-function kebab(s) {
-  return s.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
-}
-
-async function main() {
-  const args = parseArgs(process.argv);
-  require_(args, "project");
-  require_(args, "workspace");
-
-  const workspaceDir = path.resolve(args.workspace);
-  const identity = resolveIdentity(args);
-  const outDir = args.out
-    ? path.resolve(args.out)
-    : path.join(workspaceDir, "dist", "admin-remotes");
-
-  const libDist = path.join(workspaceDir, "dist", identity.id);
-  if (!fs.existsSync(libDist)) {
-    console.error(
-      `Lib dist not found at ${libDist}. Run \`ng build ${identity.id}\` first.`
-    );
-    process.exit(1);
-  }
-
-  console.log(
-    `ws-pack-remote: id=${identity.id} remoteName=${
-      identity.remoteName
-    } → ${path.join(outDir, identity.id)}/`
-  );
-
-  const aliasMap = discoverWorkspaceAliases(workspaceDir);
-  if (!aliasMap[identity.id]) {
-    console.error(
-      `Lib '${identity.id}' not recognized as ng-package output (missing module/main in dist/${identity.id}/package.json).`
-    );
-    process.exit(1);
-  }
-
-  const synthetic = writeSyntheticEntry(identity.id);
-
-  let webpack;
-  try {
-    const requireFromWorkspace = Module.createRequire(
-      path.join(workspaceDir, "package.json")
-    );
-    webpack = requireFromWorkspace("webpack");
-  } catch (e) {
-    console.error(
-      `Failed to load webpack from workspace ${workspaceDir}: ${e.message}`
-    );
-    cleanup(synthetic.dir);
-    process.exit(1);
-  }
-
-  try {
-    const sharedMap = buildSharedMap({
-      workspaceDir,
-      aliasMap,
-      selfId: identity.id,
-      sharedExtras: identity.sharedExtras,
-    });
-
-    const config = buildWebpackConfig({
-      workspaceDir,
-      syntheticEntry: synthetic.file,
-      outDir,
-      id: identity.id,
-      remoteName: identity.remoteName,
-      exposes: identity.exposes,
-      aliasMap,
-      sharedMap,
-    });
-
-    await runWebpack(webpack, config);
-
-    // Copy the lib's static assets (i18n JSON, etc.) into the remote
-    // dir so the controller serves them at the same URL space as the
-    // chunks. ng-packagr emits these to `dist/<id>/assets/` per the
-    // lib's ng-package.json `assets` field; the old *-remote projects
-    // mirrored them via angular.json `assets` globs — same effect.
-    const libAssets = path.join(workspaceDir, "dist", identity.id, "assets");
-    if (fs.existsSync(libAssets)) {
-      const targetAssets = path.join(outDir, identity.id, "remote", "assets");
-      fs.cpSync(libAssets, targetAssets, { recursive: true });
-      console.log(`  + assets ${targetAssets}`);
-    }
-
-    const descriptorPath = emitDescriptor({
-      outDir,
-      id: identity.id,
-      hostId: identity.hostId,
-      remoteName: identity.remoteName,
-      exposes: identity.exposes,
-      displayName: identity.displayName,
-    });
-
-    console.log(`  + descriptor ${descriptorPath}`);
-  } finally {
-    cleanup(synthetic.dir);
-  }
-}
-
-function runWebpack(webpack, config) {
-  return new Promise((resolve, reject) => {
-    webpack(config, (err, stats) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      const info = stats.toJson({ errors: true, warnings: true });
-      if (stats.hasErrors()) {
-        for (const e of info.errors) {
-          console.error(e.message || e);
-        }
-        reject(new Error("webpack build failed"));
-        return;
-      }
-      if (stats.hasWarnings()) {
-        for (const w of info.warnings) {
-          console.warn(w.message || w);
-        }
-      }
-      console.log(
-        stats.toString({
-          colors: true,
-          modules: false,
-          children: false,
-          chunks: false,
-          chunkModules: false,
-          entrypoints: false,
-        })
-      );
-      resolve();
-    });
-  });
-}
-
-main().catch((e) => {
-  console.error(e.stack || e.message || e);
-  process.exit(1);
-});

package/hooks/ngcc.js

@@ -1,41 +0,0 @@
-// Built-in federation postInstall hook: run ngcc against the federation
-// node_modules tree so every @angular package gets `__processed_by_ivy_ngcc__`
-// markers and class definitions rewritten in place (ɵcmp/ɵdir/etc).
-//
-// Producers reference this hook from their lib's package.json:
-//
-//   "wsmodules": {
-//     "federationHooks": { "postInstall": "@ws-test-realm/admin-kit/hooks/ngcc" }
-//   }
-//
-// The hook resolves `@angular/compiler-cli/ngcc` from the PRODUCER workspace
-// (where compiler-cli is installed as a dev dep, alongside ng-cli, etc.).
-// The federation tree itself only holds runtime peer deps and won't have
-// compiler-cli unless a lib explicitly declares it.
-
-const Module = require("module");
-const path = require("path");
-
-module.exports = function ngccHook({ federationDir, producerWorkspaceDir, libName }) {
-  const requireFromProducer = Module.createRequire(
-    path.join(producerWorkspaceDir, "package.json")
-  );
-  let ngcc;
-  try {
-    ngcc = requireFromProducer("@angular/compiler-cli/ngcc");
-  } catch (e) {
-    console.warn(
-      `\x1b[33mWarning:\x1b[0m ngcc hook (${libName}): couldn't load @angular/compiler-cli/ngcc from ${producerWorkspaceDir}: ${e.message}`
-    );
-    return;
-  }
-
-  const basePath = path.join(federationDir, "node_modules");
-  console.log(`  ngcc: rewriting ${basePath}`);
-  ngcc.process({
-    basePath,
-    propertiesToConsider: ["module_ivy_ngcc", "browser", "module", "main"],
-    compileAllFormats: false,
-    async: false,
-  });
-};

package/lib/alias-discovery.js

@@ -1,40 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-
-// Scan <workspace>/dist/* for ng-package-style outputs and return a map
-// {<libName>: <absolute path to dist/<libName>>}. An ng-package output is
-// recognized by having a package.json that declares either "module" or
-// "main" — that distinguishes it from the *-remote outputs (which we want
-// to ignore — they are webpack bundles, not consumable libs).
-function discoverWorkspaceAliases(workspaceDir) {
-  const distDir = path.join(workspaceDir, "dist");
-  if (!fs.existsSync(distDir)) return {};
-
-  const aliases = {};
-  for (const name of fs.readdirSync(distDir)) {
-    const dir = path.join(distDir, name);
-    let stat;
-    try {
-      stat = fs.statSync(dir);
-    } catch (e) {
-      continue;
-    }
-    if (!stat.isDirectory()) continue;
-
-    const pkgPath = path.join(dir, "package.json");
-    if (!fs.existsSync(pkgPath)) continue;
-
-    let pkg;
-    try {
-      pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-    } catch (e) {
-      continue;
-    }
-    if (!pkg.module && !pkg.main) continue;
-
-    aliases[name] = dir;
-  }
-  return aliases;
-}
-
-module.exports = { discoverWorkspaceAliases };

package/lib/federation-peers.js

@@ -1,184 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const Module = require("module");
-const { execSync } = require("child_process");
-
-// Mirror a federation lib's peerDependencies into its dependencies in the
-// STAGED package.json under <adminDir>/.federation/<id>/. ng-packagr emits
-// peerDependencies — the canonical contract for a published library — but
-// for our publish-less federation we want npm to actually INSTALL those
-// peers (so consuming workspaces' TypeScript can resolve their types via
-// walk-up from .federation/<id>/). Promoting peer → dep in the staged copy
-// only doesn't touch the producer's source.
-function promotePeerDeps(libDir) {
-  const pkgPath = path.join(libDir, "package.json");
-  if (!fs.existsSync(pkgPath)) return false;
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-  if (!pkg.peerDependencies || !Object.keys(pkg.peerDependencies).length) {
-    return false;
-  }
-  pkg.dependencies = Object.assign({}, pkg.dependencies, pkg.peerDependencies);
-  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  return true;
-}
-
-// Reconcile the entire .federation/ dir as an npm workspace root. Lists
-// every lib subdir as a workspace, runs `npm install` (npm hoists shared
-// peer versions, nests only on per-lib disagreement), then runs each
-// lib's declared postInstall hooks against the freshly installed tree.
-//
-// Hooks let a federation lib ship arbitrary prep work that consumers run
-// automatically — e.g. ws-framework declares
-// `wsmodules.federationHooks.postInstall = "@ws-test-realm/admin-kit/hooks/ngcc"`
-// so the consumer's install pipeline Ivy-rewrites the Angular tree in
-// place. admin-kit knows nothing about Angular here; the producer's
-// declaration drives what runs.
-//
-// Idempotent. Re-runs at the end of every deploy.
-function syncFederationWorkspace(adminDir, producerWorkspaceDir) {
-  const federationDir = path.join(adminDir, ".federation");
-  if (!fs.existsSync(federationDir)) return { installed: false };
-
-  const libs = listFederationLibs(federationDir);
-  if (!libs.length) return { installed: false };
-
-  writeWorkspaceManifest(federationDir, libs);
-
-  console.log(
-    `\n=== federation peers: install (${libs.length} workspace${libs.length === 1 ? "" : "s"}) ===`
-  );
-  console.log(`  at ${federationDir}`);
-  execSync("npm install --no-package-lock --no-audit --no-fund", {
-    cwd: federationDir,
-    stdio: "inherit",
-  });
-
-  runFederationHooks({ federationDir, libs, producerWorkspaceDir });
-
-  return { installed: true, libs };
-}
-
-// Walk each federation lib's package.json for declared postInstall hooks
-// (`wsmodules.federationHooks.postInstall`, string or array). Dedupe by
-// hook reference — multiple libs declaring the same hook (e.g. all
-// Angular libs referencing the built-in ngcc hook) run it once. Each hook
-// is a CommonJS module exporting a default function with signature
-// `({ federationDir, libDir, libName, producerWorkspaceDir }) => void`.
-//
-// Hook reference resolution:
-//   - "./..." or "../..."  → relative to the lib's federation dir
-//   - any other specifier  → node `require` resolution, first trying
-//                             admin-kit's own neighborhood (built-in hooks
-//                             like @ws-test-realm/admin-kit/hooks/ngcc),
-//                             then the producer workspace (third-party
-//                             hook packages).
-function runFederationHooks({ federationDir, libs, producerWorkspaceDir }) {
-  const queue = [];
-  const seen = new Set();
-  for (const libName of libs) {
-    const libDir = path.join(federationDir, libName);
-    const pkg = safeReadJson(path.join(libDir, "package.json"));
-    const refs = collectHookRefs(pkg);
-    for (const ref of refs) {
-      if (seen.has(ref)) continue;
-      seen.add(ref);
-      queue.push({ ref, libDir, libName });
-    }
-  }
-  if (!queue.length) return;
-
-  console.log(
-    `\n=== federation peers: postInstall hooks (${queue.length}) ===`
-  );
-  for (const { ref, libDir, libName } of queue) {
-    console.log(`  ${libName} → ${ref}`);
-    let hookFn;
-    try {
-      hookFn = resolveHook({ ref, libDir, producerWorkspaceDir });
-    } catch (e) {
-      console.warn(
-        `  \x1b[33mWarning:\x1b[0m couldn't load hook (${e.message})`
-      );
-      continue;
-    }
-    if (typeof hookFn !== "function") {
-      console.warn(
-        `  \x1b[33mWarning:\x1b[0m hook ${ref} did not export a function`
-      );
-      continue;
-    }
-    try {
-      hookFn({ federationDir, libDir, libName, producerWorkspaceDir });
-    } catch (e) {
-      console.warn(
-        `  \x1b[33mWarning:\x1b[0m hook ${ref} threw: ${e.message}`
-      );
-    }
-  }
-}
-
-function collectHookRefs(pkg) {
-  if (!pkg || !pkg.wsmodules || !pkg.wsmodules.federationHooks) return [];
-  const v = pkg.wsmodules.federationHooks.postInstall;
-  if (!v) return [];
-  return Array.isArray(v) ? v : [v];
-}
-
-function resolveHook({ ref, libDir, producerWorkspaceDir }) {
-  let resolvedPath;
-  if (ref.startsWith("./") || ref.startsWith("../")) {
-    resolvedPath = path.resolve(libDir, ref);
-  } else {
-    const adminKitRequire = Module.createRequire(
-      path.join(__dirname, "..", "package.json")
-    );
-    try {
-      resolvedPath = adminKitRequire.resolve(ref);
-    } catch {
-      const producerRequire = Module.createRequire(
-        path.join(producerWorkspaceDir, "package.json")
-      );
-      resolvedPath = producerRequire.resolve(ref);
-    }
-  }
-  return require(resolvedPath);
-}
-
-function listFederationLibs(federationDir) {
-  return fs
-    .readdirSync(federationDir, { withFileTypes: true })
-    .filter((e) => e.isDirectory())
-    .map((e) => e.name)
-    .filter((name) => {
-      if (name === "node_modules") return false;
-      return fs.existsSync(path.join(federationDir, name, "package.json"));
-    })
-    .sort();
-}
-
-function writeWorkspaceManifest(federationDir, libs) {
-  const pkg = {
-    name: "ws-federation-host",
-    private: true,
-    version: "0.0.0",
-    workspaces: libs.map((id) => `./${id}`),
-  };
-  fs.writeFileSync(
-    path.join(federationDir, "package.json"),
-    JSON.stringify(pkg, null, 2) + "\n"
-  );
-}
-
-function safeReadJson(file) {
-  try {
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return null;
-  }
-}
-
-module.exports = {
-  promotePeerDeps,
-  syncFederationWorkspace,
-  listFederationLibs,
-};

package/lib/shared-deps.js

@@ -1,90 +0,0 @@
-// Build the `shared` map for ModuleFederationPlugin.
-//
-// Layers (later wins):
-//   1. sharedDescriptors() from @wiresphere/shared (host baseline:
-//      @angular/*, rxjs, etc.).
-//   2. Workspace-discovered libs (from alias map) as WORKSPACE_LIBS shape.
-//   3. Self-lib forced to import: false so the container does not load
-//      itself back through the shared scope.
-//   4. sharedExtras from pack.config.json (project overrides).
-//
-// Then for any entry left with `requiredVersion: 'auto'` we resolve the
-// version from <workspaceDir>/node_modules/<pkg>/package.json BEFORE handing
-// the map to share(). share()'s built-in auto-probe reads the workspace's
-// own package.json, which no longer lists Angular/rxjs/etc. directly — those
-// are pulled in transitively via @wiresphere/shared. Probing node_modules
-// closes that gap.
-const fs = require("fs");
-const path = require("path");
-
-function packageRootOf(key) {
-  if (key.startsWith("@")) {
-    const parts = key.split("/");
-    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : key;
-  }
-  return key.split("/")[0];
-}
-
-function tryReadVersion(workspaceDir, pkgRoot) {
-  const pkgJsonPath = path.join(
-    workspaceDir,
-    "node_modules",
-    pkgRoot,
-    "package.json"
-  );
-  try {
-    return JSON.parse(fs.readFileSync(pkgJsonPath, "utf8")).version || null;
-  } catch {
-    return null;
-  }
-}
-
-function resolveAutoVersions(map, workspaceDir) {
-  const out = {};
-  for (const [key, val] of Object.entries(map)) {
-    if (val && val.requiredVersion === "auto") {
-      const version = tryReadVersion(workspaceDir, packageRootOf(key));
-      out[key] = Object.assign({}, val, {
-        requiredVersion: version || false,
-      });
-    } else {
-      out[key] = val;
-    }
-  }
-  return out;
-}
-
-function buildSharedMap({ workspaceDir, aliasMap, selfId, sharedExtras }) {
-  const wsShared = require("@ws-test-realm/shared");
-  const { share } = require("@angular-architects/module-federation/webpack");
-
-  const WORKSPACE_LIBS = wsShared.WORKSPACE_LIBS || {
-    singleton: true,
-    strictVersion: false,
-    requiredVersion: false,
-  };
-
-  const map = Object.assign({}, wsShared.sharedDescriptors());
-
-  for (const libName of Object.keys(aliasMap)) {
-    if (libName.endsWith("-remote")) continue;
-    if (libName === selfId) {
-      if (!map[libName]) {
-        map[libName] = Object.assign({}, WORKSPACE_LIBS);
-      }
-    } else {
-      map[libName] = Object.assign({}, WORKSPACE_LIBS, {
-        import: false,
-      });
-    }
-  }
-
-  for (const [k, v] of Object.entries(sharedExtras || {})) {
-    map[k] = Object.assign({}, map[k] || {}, v);
-  }
-
-  const resolved = resolveAutoVersions(map, workspaceDir);
-  return share(resolved, workspaceDir);
-}
-
-module.exports = { buildSharedMap };

package/lib/synthetic-entry.js

@@ -1,27 +0,0 @@
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
-const crypto = require("crypto");
-
-// Writes a temp directory containing a single `public-api.ts` that
-// re-exports everything from the lib's import path. Webpack's MF
-// `exposes['./Module']` points at this file; the import resolves
-// through the workspace alias for `<id>` (set up in webpack.resolve).
-function writeSyntheticEntry(id) {
-  const hash = crypto.randomBytes(4).toString("hex");
-  const dir = path.join(os.tmpdir(), "ws-pack-remote", `${id}-${hash}`);
-  fs.mkdirSync(dir, { recursive: true });
-  const file = path.join(dir, "public-api.ts");
-  fs.writeFileSync(file, `export * from '${id}';\n`, "utf8");
-  return { dir, file };
-}
-
-function cleanup(dir) {
-  try {
-    fs.rmSync(dir, { recursive: true, force: true });
-  } catch (e) {
-    // best-effort cleanup
-  }
-}
-
-module.exports = { writeSyntheticEntry, cleanup };

package/lib/webpack-factory.js

@@ -1,120 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const Module = require("module");
-const TsconfigPathsPlugin = require("tsconfig-paths-webpack-plugin");
-
-// Build the in-memory webpack config used to produce a federated remote
-// from a single synthetic entry that re-exports the lib's public API.
-//
-// We resolve the workspace's webpack + ModuleFederationPlugin so the
-// build runs against the same versions used by the workspace's own
-// dependency graph (avoids shared-scope ABI surprises).
-function buildWebpackConfig({
-  workspaceDir,
-  syntheticEntry,
-  outDir,
-  id,
-  remoteName,
-  exposes,
-  aliasMap,
-  sharedMap,
-}) {
-  const requireFromWorkspace = Module.createRequire(
-    path.join(workspaceDir, "package.json")
-  );
-  const ModuleFederationPlugin = requireFromWorkspace(
-    "webpack/lib/container/ModuleFederationPlugin"
-  );
-  const babelLoader = requireFromWorkspace.resolve("babel-loader");
-  const linkerPlugin = requireFromWorkspace.resolve(
-    "@angular/compiler-cli/linker/babel"
-  );
-
-  const remoteOutDir = path.join(outDir, id, "remote");
-
-  // tsconfig.federation.json is the SSOT for cross-workspace paths
-  // (`@ws-remote/*` → `<adminDir>/.federation/*`, sibling lib aliases,
-  // etc.). Without this plugin webpack ignores tsconfig `paths` and
-  // walks node_modules — which fails for cross-workspace federation
-  // siblings that only live in the host's federation dir.
-  const federationTsconfig = path.join(workspaceDir, "tsconfig.federation.json");
-  const resolvePlugins = [];
-  if (fs.existsSync(federationTsconfig)) {
-    resolvePlugins.push(
-      new TsconfigPathsPlugin({ configFile: federationTsconfig })
-    );
-  }
-
-  return {
-    mode: "production",
-    entry: syntheticEntry,
-    context: workspaceDir,
-    // Terser's default class-name mangling strips identifying info
-    // Angular's runtime relies on (you get `'_' is neither
-    // ComponentType nor DirectiveType` errors). Angular CLI's builder
-    // configures Terser with Angular-aware options; we don't, so keep
-    // minimization off until that config is ported. Output is larger
-    // but functionally correct.
-    optimization: {
-      minimize: false,
-    },
-    output: {
-      path: remoteOutDir,
-      publicPath: "auto",
-      uniqueName: remoteName,
-      // Content-hash all chunks so the controller can serve them
-      // with immutable caching. The MF plugin overrides this to
-      // "remoteEntry.js" for the entry only — that one stays at a
-      // stable URL and is revalidated each load.
-      filename: "[name].[contenthash:10].js",
-      chunkFilename: "[name].[contenthash:10].js",
-    },
-    resolve: {
-      alias: aliasMap,
-      plugins: resolvePlugins,
-      extensions: [".ts", ".js", ".mjs", ".json"],
-      // ngcc rewrites Angular packages in-place but leaves the
-      // originals next to them, exposing both via package.json fields
-      // (`module` for the partial-Ivy original, `module_ivy_ngcc` for
-      // the full-Ivy processed copy). Webpack's default mainFields
-      // doesn't know about the latter — it resolves to the partial
-      // version and components show up as `'MatInput' is neither
-      // ComponentType nor DirectiveType` because their `ɵdir` static
-      // is missing. Angular CLI's builder injects this same ordering.
-      mainFields: ["module_ivy_ngcc", "browser", "module", "main"],
-    },
-    module: {
-      rules: [
-        // Run the Angular partial-Ivy linker over every JS module.
-        // ng-packagr emits libs in compilationMode "partial" by
-        // default since v12; the runtime can't always process
-        // partial declarations directly (we hit
-        // `meta.deps.map is not a function` in ɵɵngDeclareFactory).
-        // Babel-with-linker rewrites the partial declarations to
-        // full Ivy at bundle time — same step that Angular CLI's
-        // custom-webpack:browser builder does implicitly.
-        {
-          test: /\.m?js$/,
-          loader: babelLoader,
-          options: {
-            compact: false,
-            cacheDirectory: true,
-            plugins: [linkerPlugin],
-          },
-          resolve: { fullySpecified: false },
-        },
-      ],
-    },
-    plugins: [
-      new ModuleFederationPlugin({
-        name: remoteName,
-        library: { type: "window", name: remoteName },
-        filename: "remoteEntry.js",
-        exposes: { [exposes]: syntheticEntry },
-        shared: sharedMap,
-      }),
-    ],
-  };
-}
-
-module.exports = { buildWebpackConfig };

package/template-module/ng-package.json

@@ -1,8 +0,0 @@
-{
-	"$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
-	"dest": "../../dist/__name__",
-	"assets": ["./assets"],
-	"lib": {
-		"entryFile": "src/public-api.ts"
-	}
-}

package/template-module/tsconfig.lib.json

@@ -1,13 +0,0 @@
-{
-	"extends": "../../tsconfig.json",
-	"compilerOptions": {
-		"outDir": "../../out-tsc/lib",
-		"target": "es2015",
-		"declaration": true,
-		"declarationMap": true,
-		"inlineSources": true,
-		"types": [],
-		"lib": ["dom", "es2018"]
-	},
-	"exclude": ["**/*.spec.ts"]
-}

package/template-module/tsconfig.lib.prod.json

@@ -1,9 +0,0 @@
-{
-	"extends": "./tsconfig.lib.json",
-	"compilerOptions": {
-		"declarationMap": false
-	},
-	"angularCompilerOptions": {
-		"compilationMode": "partial"
-	}
-}