@maka/meteor-sdk 0.2.11 → 0.2.13

package/src/bundle.js

@@ -25,6 +25,19 @@ async function bundle(project, options) {
     throw new MeteorSdkError("bundle() requires options.outputPath");
   }
 
+  // Validate BEFORE the expensive build, same spirit as the outputPath
+  // check above. 'server' writes a bundle without client programs whose
+  // config.json still records the intended clientArchs; 'client' writes
+  // a standalone client-only star (no server program, no main.js) whose
+  // programs/<arch> trees are drop-in siblings for a server bundle.
+  const programs = options.programs || "all";
+  if (!["all", "server", "client"].includes(programs)) {
+    throw new MeteorSdkError(
+      "bundle() options.programs must be 'all', 'server' or 'client' " +
+        "(got " + JSON.stringify(options.programs) + ")"
+    );
+  }
+
   const bundler = require("../tools/isobuild/bundler.js");
 
   const result = await bundler.bundle({
@@ -35,6 +48,7 @@ async function bundle(project, options) {
       buildMode: options.buildMode || "production",
       serverArch: options.serverArch,
       webArchs: options.webArchs,
+      programs,
     },
   });
 

package/tools/isobuild/bundler.js

@@ -3300,6 +3300,12 @@ Find out more about Meteor at meteor.com.
  *     of debugOnly, prodOnly and testOnly packages, default 'production'
  *   - webArchs: array of 'web.*' options to build (defaults to
  *     projectContext.platformList.getWebArchs())
+ *   - programs: 'all' (default), 'server' or 'client'. 'server' writes a
+ *     bundle without client programs whose config.json still records the
+ *     intended clientArchs (webapp serves them when the client artifact
+ *     arrives at the sibling path); 'client' writes a standalone
+ *     client-only star -- programs/<arch> trees byte-identical to a full
+ *     bundle's, no server program, no main.js.
  *   - warnings: a MessageSet of linting messages or null if linting
  *     wasn't performed at all (either disabled or lack of linters).
  *
@@ -3364,6 +3370,16 @@ async function bundle({
   }
   const minifyMode = buildOptions.minifyMode || 'development';
   const buildMode = buildOptions.buildMode || 'production';
+  // Which programs to build and write: 'all' (default), 'server' (skip
+  // the client targets but still record the INTENDED clientArchs in
+  // programs/server/config.json, so webapp serves them once the client
+  // artifact arrives -- missing-at-boot is already tolerated, see
+  // webapp_server.js generateClientProgram's ENOENT path), or 'client'
+  // (skip the server target; writeSiteArchive already gates main.js,
+  // README and config.json on targets.server, so the client-only
+  // artifact falls out honest: a star.json listing only web archs plus
+  // programs/<arch>/ trees byte-identical to a full bundle's).
+  const programs = buildOptions.programs || 'all';
 
   var releaseName =
     release.current.isCheckout() ? "none" : release.current.name;
@@ -3389,6 +3405,11 @@ async function bundle({
     throw new Error('Unrecognized build mode: ' + buildMode);
   }
 
+  if (! ['all', 'server', 'client'].includes(programs)) {
+    throw new Error('Unrecognized programs selection: ' + programs +
+                    " (expected 'all', 'server' or 'client')");
+  }
+
   var messages = await buildmessage.capture({
     title: "building the application"
   }, async function () {
@@ -3520,13 +3541,25 @@ async function bundle({
       previousBuilders[arch] = written.builder;
     }
 
-    // Client
-    for (const arch of webArchs) {
-      targets[arch] = await makeClientTarget(app, arch, {minifiers});
+    // Client. Skipped entirely for a server-only build -- but note
+    // webArchs itself is NOT emptied: makeServerTarget below still
+    // receives the full list, so programs/server/config.json records
+    // the INTENDED clientArchs and the server will serve those programs
+    // the moment the separately-deployed client artifact appears at the
+    // sibling path (webapp tolerates missing-at-boot; ENOENT skip in
+    // generateClientProgram).
+    if (programs !== 'server') {
+      for (const arch of webArchs) {
+        targets[arch] = await makeClientTarget(app, arch, {minifiers});
+      }
     }
 
-    // Server
-    if (! hasCachedBundle) {
+    // Server. Skipped for a client-only build: writeSiteArchive already
+    // gates main.js/README/config.json on targets.server, so the
+    // resulting artifact is an honest client-only star -- programs list
+    // holds only web archs, and the program dirs are byte-identical to
+    // a full bundle's (drop-in compatible as siblings).
+    if (! hasCachedBundle && programs !== 'client') {
       targets.server = await makeServerTarget(app, webArchs);
     }
 

package/tools/static-assets/server/boot.js

@@ -207,9 +207,18 @@ var specialArgPaths = {
     var clientArchs = configJson.clientArchs ||
       Object.keys(configJson.clientPaths);
 
+    // METEOR_CLIENT_BUNDLE_DIR relocates the CLIENT programs (split
+    // server/client deploys -- a directory containing <arch>/ program
+    // dirs). Must agree with webapp_server.js's generateClientProgram,
+    // which honors the same variable: dynamic-import fetches modules
+    // from disk independently of webapp's static file map, so missing
+    // this one silently breaks import() while pages still serve.
+    var clientProgramsDir =
+      process.env.METEOR_CLIENT_BUNDLE_DIR || programsDir;
+
     clientArchs.forEach(function (arch) {
       dynamicImportInfo[arch] = {
-        dynamicRoot: path.join(programsDir, arch, "dynamic")
+        dynamicRoot: path.join(clientProgramsDir, arch, "dynamic")
       };
     });
 

package/tools/static-assets/server/runtime.js

@@ -3,6 +3,60 @@ const path = require('path');
 const { createHash } = require("crypto");
 const Module = module.constructor;
 
+// Whether Node will treat a .js file as NATIVE ESM: nearest package.json
+// declares "type": "module". Such files must NEVER be reify-compiled --
+// modern Node's own CJS loader routes them through
+// require(esm)/loadESMFromCJS, and V8 then evaluates whatever text the
+// _compile hook below passed along UNDER ESM RULES at the file's own URL.
+// Feeding it reify output ("use strict";module.export(...)) produces
+// "module is not defined in ES module scope" from a file that is pristine
+// ESM on disk -- a production outage class found the hard way (the
+// @maka/maka-cli engine's type:module files, 2026-08-30): the failure
+// selector LOOKED like "contains createRequire" but is actually "reify
+// made changes", i.e. any real top-level import/export; files reached via
+// the ESM import graph bypass the CJS hook and load clean, which is what
+// made the pattern so misleading. Memoized per directory -- this runs on
+// the require hot path.
+const dirTypeCache = Object.create(null);
+function nearestPackageTypeIsModule(filename) {
+  let dir = path.dirname(filename);
+  const seen = [];
+  while (true) {
+    if (dir in dirTypeCache) {
+      break;
+    }
+    seen.push(dir);
+    let found = null;
+    try {
+      const raw = fs.readFileSync(path.join(dir, 'package.json'), 'utf8');
+      // Nearest package.json wins, whatever it says; an unparsable or
+      // type-less one still STOPS the walk (Node semantics).
+      let type = null;
+      try {
+        type = JSON.parse(raw).type || null;
+      } catch (e) {}
+      found = { stop: true, isModule: type === 'module' };
+    } catch (e) {
+      found = null;
+    }
+    if (found) {
+      dirTypeCache[dir] = found.isModule;
+      break;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      dirTypeCache[dir] = false;
+      break;
+    }
+    dir = parent;
+  }
+  const result = dirTypeCache[dir];
+  for (const d of seen) {
+    dirTypeCache[d] = result;
+  }
+  return result;
+}
+
 module.exports = function enable ({ cachePath, createLoader = true } = {}) {
   let cacheEnabled = !!cachePath;
   let cacheEntries = Object.create(null);
@@ -83,17 +137,42 @@ module.exports = function enable ({ cachePath, createLoader = true } = {}) {
 
   const _compile = Mp._compile;
   Mp._compile = function (content, filename, options) {
-    // When cache is enabled, the file has already been compiled
-    if (!options || !options.compiledWithReify) {
+    // Modern Node passes a FORMAT STRING ('module'/'commonjs') as the
+    // third argument on some paths; only our own internal call passes an
+    // object. Treat anything ESM-destined as untouchable (see
+    // nearestPackageTypeIsModule above), and otherwise leave already-
+    // compiled content alone.
+    const alreadyCompiled =
+      options && typeof options === 'object' && options.compiledWithReify;
+    const isEsm =
+      options === 'module' ||
+      (typeof filename === 'string' && nearestPackageTypeIsModule(filename));
+
+    if (!alreadyCompiled && !isEsm) {
       content = compileContent(content).content;
     }
 
-    return _compile.call(this, content, filename);
+    // Forward the third argument: dropping it discarded Node's own format
+    // hint and forced a re-derivation downstream. Our internal object is
+    // NOT forwarded (native _compile expects Node's own shapes there).
+    const forward =
+      options && typeof options === 'object' ? undefined : options;
+    return _compile.call(this, content, filename, forward);
   };
 
   if (cacheEnabled) {
-    const jsExt = Module._extensions.js;
+    // NOTE the bracket key: `Module._extensions.js` (the original line
+    // here) reads a property literally named "js", which does not exist
+    // -- the real key is ".js". Harmless while jsExt was unused; fatal
+    // once the ESM passthrough below actually delegates to it.
+    const jsExt = Module._extensions['.js'];
     Module._extensions['.js'] = function (module, filename) {
+      // ESM-destined files: hand straight back to Node's own loader,
+      // which reads pristine bytes and routes require(esm) correctly.
+      // Never cache them -- the cache stores reify output.
+      if (nearestPackageTypeIsModule(filename)) {
+        return jsExt(module, filename);
+      }
       let stat = fs.statSync(filename);
       let baseKey = createHash("sha1")
         .update(`${reifyVersion}\0${filename}\0${stat.mtimeMs}\0${stat.ino}\0${stat.size}\0`)