@reventlessdev/reventless-aws 3.0.0-alpha.343 → 3.0.0-alpha.344

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.344 (2026-09-09)
+
+### Bug Fixes
+
+* **aws:** the archive asks what the layer holds, not what resolves ([fca352f](https://github.com/ReventlessDev/reventless-core/commit/fca352f7a19f0518a84944d4efd23eb98285f6bf))
+
+
 # 3.0.0-alpha.343 (2026-09-08)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.343",
+  "version": "3.0.0-alpha.344",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -15,18 +15,18 @@
     "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.16",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.11",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.16",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.10",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.161",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.260",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.35",
     "@reventlessdev/reventless-postgres": "3.0.0-alpha.124",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.161",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.133",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.260"
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/util/Util_Bundle.res

@@ -349,32 +349,35 @@ let isRuntimeProvided = (specifier: string, ~pkgName: string): bool =>
     }
   )
 
-// Memo for isFrameworkPackage — one require.resolve per package name per deploy.
-let frameworkPackageCache: dict<bool> = Dict.make()
-
-/**
- * Whether the framework's own module resolution reaches this package: the
- * deploy-time stand-in for "the Lambda layer already carries it", since the
- * layer is built from reventless-aws's dependency closure.
- *
- * Deliberately framework-rooted only — no Pulumi-project fallback. The question
- * here is the opposite of `resolvePackageRoot`'s: a package the *project*
- * resolves but the framework does not is precisely a user package, which is
- * what the closure walk below must treat as a starting point rather than as
- * something the runtime provides.
- */
-let isFrameworkPackage = (pkgName: string): bool =>
-  switch frameworkPackageCache->Dict.get(pkgName) {
-  | Some(known) => known
-  | None =>
-    let known = try {
-      let _ = localRequire->NodeModule.requireResolve(pkgName ++ "/package.json")
-      true
-    } catch {
-    | _ => false
+/** The framework's own package root: this module ships inside reventless-aws, so
+    the nearest package.json walking up from it is reventless-aws's own. */
+let frameworkPackageRoot: string = {
+  let filePath = newURL(%raw("import.meta.url"))->pathname
+  let dirRef = ref(NodePath.dirname(filePath))
+  let foundRef: ref<option<string>> = ref(None)
+  while dirRef.contents != "/" && foundRef.contents->Option.isNone {
+    if NodeFs.existsSync(NodePath.join([dirRef.contents, "package.json"])) {
+      foundRef := Some(dirRef.contents)
+    } else {
+      dirRef := NodePath.dirname(dirRef.contents)
     }
-    frameworkPackageCache->Dict.set(pkgName, known)
-    known
+  }
+  foundRef.contents->Option.getOr(NodePath.dirname(filePath))
+}
+
+/** The `dependencies` a package declares — the edges the layer's own npm install
+    follows. devDependencies are deliberately not read: the layer is a production
+    install, so a dev-only package is not in it. */
+let declaredDependencies = (packageRoot: string): array<string> =>
+  try {
+    NodeFs.readFileSync(NodePath.join([packageRoot, "package.json"]))
+    ->JSON.parseOrThrow
+    ->JSON.Decode.object
+    ->Option.flatMap(o => o->Dict.get("dependencies"))
+    ->Option.flatMap(JSON.Decode.object)
+    ->Option.mapOr([], Dict.keysToArray)
+  } catch {
+  | _ => []
   }
 
 // The distinct bare packages a package's own bundled files import, memoised per
@@ -427,6 +430,76 @@ let resolvePackageRootFrom = (~fromRoot: string, pkgName: string): option<string
   | _ => None
   }
 
+/** Packages the layer carries that reventless-aws does not declare, mirroring
+    `includeModules` in the layer builder's config. `@rescript/runtime` is the
+    case that matters: it is a transitive of `rescript`, which the layer excludes
+    as a build tool, so the production closure misses it while the layer holds
+    it. Without this the walk would add 19 MB to every archive.
+
+    The layer's `excludeModules` are deliberately NOT mirrored. Those are
+    deploy-time-only packages (the @pulumi bindings, esbuild, the SSH stack); the
+    walk is import-driven, so a package no runtime file imports never comes up. */
+let layerIncludedModules = Set.fromArray(["@rescript/runtime"])
+
+// Memo for the framework's dependency closure — one walk per deploy.
+let frameworkClosureCache: ref<option<dict<bool>>> = ref(None)
+
+/**
+ * The packages the Lambda layer carries: reventless-aws and its transitive
+ * `dependencies`, which is exactly what the layer builder npm-installs.
+ *
+ * Membership rather than resolvability, and the distinction is the whole point.
+ * Resolvability asked whether `require.resolve` reaches a package from this
+ * module — but Node resolution walks *up*, so in a consumer repo with a hoisted
+ * `node_modules` every package at the workspace root answers yes, including the
+ * plugin packages and their traits. That made this predicate true for packages
+ * the layer has never held: they were dropped from the archive as
+ * layer-provided, and the plugin package itself was filtered out of the closure
+ * walk's starting points, so its imports were never walked at all. The failure
+ * lands at the first command as `Cannot find package`, on a green deploy.
+ *
+ * Declared edges are followed from the declaring package's own directory, so a
+ * pnpm layout resolves the same way the runtime would. A dependency that is
+ * declared but not installed still counts as the layer's: the archive is not the
+ * place to compensate for an incomplete install.
+ */
+let frameworkPackages = (): dict<bool> =>
+  switch frameworkClosureCache.contents {
+  | Some(closure) => closure
+  | None =>
+    let closure = Dict.make()
+    let pending = [frameworkPackageRoot]
+    let next = ref(0)
+    while next.contents < pending->Array.length {
+      let root = pending->Array.getUnsafe(next.contents)
+      next := next.contents + 1
+      declaredDependencies(root)->Array.forEach(dep =>
+        if !(closure->Dict.has(dep)) {
+          closure->Dict.set(dep, true)
+          switch resolvePackageRootFrom(~fromRoot=root, dep) {
+          | Some(depRoot) => pending->Array.push(depRoot)
+          | None => ()
+          }
+        }
+      )
+    }
+    frameworkClosureCache := Some(closure)
+    closure
+  }
+
+/**
+ * Whether the deployed runtime already carries this package, so the archive
+ * need not: reventless-aws itself, or anything in its dependency closure.
+ *
+ * A package the *project* resolves but this does not is precisely a user
+ * package, which the closure walk below must treat as a starting point rather
+ * than as something the runtime provides.
+ */
+let isFrameworkPackage = (pkgName: string): bool =>
+  pkgName == "@reventlessdev/reventless-aws" ||
+  layerIncludedModules->Set.has(pkgName) ||
+  frameworkPackages()->Dict.has(pkgName)
+
 /**
  * Carry every package a bundled *user* package imports into the archive, and
  * every package those import in turn.

package/src/util/Util_Bundle.res.mjs

@@ -232,22 +232,28 @@ function isRuntimeProvided(specifier, pkgName) {
   }
 }
 
-let frameworkPackageCache = {};
+let filePath = new URL(import.meta.url).pathname;
 
-function isFrameworkPackage(pkgName) {
-  let known = frameworkPackageCache[pkgName];
-  if (known !== undefined) {
-    return known;
+let dirRef = Nodepath.dirname(filePath);
+
+let foundRef;
+
+while (dirRef !== "/" && Stdlib_Option.isNone(foundRef)) {
+  if (Nodefs.existsSync(Nodepath.join(dirRef, "package.json"))) {
+    foundRef = dirRef;
+  } else {
+    dirRef = Nodepath.dirname(dirRef);
   }
-  let known$1;
+};
+
+let frameworkPackageRoot = Stdlib_Option.getOr(foundRef, Nodepath.dirname(filePath));
+
+function declaredDependencies(packageRoot) {
   try {
-    localRequire.resolve(pkgName + "/package.json");
-    known$1 = true;
+    return Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(Nodefs.readFileSync(Nodepath.join(packageRoot, "package.json"), "utf8"))), o => o["dependencies"]), Stdlib_JSON.Decode.object), [], prim => Object.keys(prim));
   } catch (exn) {
-    known$1 = false;
+    return [];
   }
-  frameworkPackageCache[pkgName] = known$1;
-  return known$1;
 }
 
 let importedPackagesCache = {};
@@ -289,6 +295,47 @@ function resolvePackageRootFrom(fromRoot, pkgName) {
   }
 }
 
+let layerIncludedModules = new Set(["@rescript/runtime"]);
+
+let frameworkClosureCache = {
+  contents: undefined
+};
+
+function frameworkPackages() {
+  let closure = frameworkClosureCache.contents;
+  if (closure !== undefined) {
+    return closure;
+  }
+  let closure$1 = {};
+  let pending = [frameworkPackageRoot];
+  let next = 0;
+  while (next < pending.length) {
+    let root = pending[next];
+    next = next + 1 | 0;
+    declaredDependencies(root).forEach(dep => {
+      if (dep in closure$1) {
+        return;
+      }
+      closure$1[dep] = true;
+      let depRoot = resolvePackageRootFrom(root, dep);
+      if (depRoot !== undefined) {
+        pending.push(depRoot);
+        return;
+      }
+    });
+  };
+  frameworkClosureCache.contents = closure$1;
+  return closure$1;
+}
+
+function isFrameworkPackage(pkgName) {
+  if (pkgName === "@reventlessdev/reventless-aws" || layerIncludedModules.has(pkgName)) {
+    return true;
+  } else {
+    return pkgName in frameworkPackages();
+  }
+}
+
 function addImportedPackageClosure(packageDirs) {
   let pending = Object.entries(packageDirs).filter(param => !isFrameworkPackage(param[0]));
   let next = 0;
@@ -410,11 +457,15 @@ export {
   isBareSpecifier,
   nodeBuiltins,
   isRuntimeProvided,
-  frameworkPackageCache,
-  isFrameworkPackage,
+  frameworkPackageRoot,
+  declaredDependencies,
   importedPackagesCache,
   importedPackages,
   resolvePackageRootFrom,
+  layerIncludedModules,
+  frameworkClosureCache,
+  frameworkPackages,
+  isFrameworkPackage,
   addImportedPackageClosure,
   assertRuntimeExtensionImportsResolvable,
   buildCodeArchive,

package/tests/Util_BundleDependencyClosureTest.res

@@ -100,6 +100,32 @@ describe("Util_Bundle — bundled user packages carry their imports", () => {
     expect(bundled->Array.includes("@fixture/never-installed"))->toBe(false)
   })
 
+  testSync("a package the framework merely resolves is still bundled", () => {
+    // The layer carries reventless-aws's dependency closure and nothing else.
+    // A consumer with a hoisted node_modules puts every package at the root,
+    // where the framework's own resolution reaches it by walking up — so
+    // resolvability said "the layer has it" about packages the layer has never
+    // held, and they were dropped from the archive. `sury` above is genuinely a
+    // framework dependency; these are not, and must ride along.
+    expect(Util_Bundle.isFrameworkPackage("@fixture/closure-trait"))->toBe(false)
+    // A real, published, @reventlessdev-scoped package that is not a dependency
+    // of reventless-aws: scope is not what decides this.
+    expect(Util_Bundle.isFrameworkPackage("@reventlessdev/reventless-local"))->toBe(false)
+  })
+
+  testSync("the framework's own closure is recognised", () => {
+    expect(Util_Bundle.isFrameworkPackage("@reventlessdev/reventless-aws"))->toBe(true)
+    expect(Util_Bundle.isFrameworkPackage("sury"))->toBe(true)
+  })
+
+  testSync("a package the layer adds outside that closure counts as the layer's", () => {
+    // @rescript/runtime is a transitive of `rescript`, which the layer excludes
+    // as a build tool, so it is absent from the production closure while the
+    // layer carries it explicitly. Every compiled ReScript file imports it, and
+    // it is 19 MB — treating it as a user package puts that in every archive.
+    expect(Util_Bundle.isFrameworkPackage("@rescript/runtime"))->toBe(true)
+  })
+
   testSync("framework packages are starting points, not walked", () => {
     // Walking reventless-aws would reach its deploy-time-only imports (the
     // @pulumi bindings) and add tens of megabytes to every archive.

package/tests/Util_BundleDependencyClosureTest.res.mjs

@@ -106,6 +106,17 @@ globalThis.describe("Util_Bundle — bundled user packages carry their imports",
     let bundled = Object.keys((Util_Bundle$ReventlessAws.addImportedPackageClosure(packageDirs), packageDirs));
     globalThis.expect(bundled.includes("@fixture/never-installed")).toBe(false);
   });
+  globalThis.test("a package the framework merely resolves is still bundled", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("@fixture/closure-trait")).toBe(false);
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("@reventlessdev/reventless-local")).toBe(false);
+  });
+  globalThis.test("the framework's own closure is recognised", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("@reventlessdev/reventless-aws")).toBe(true);
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("sury")).toBe(true);
+  });
+  globalThis.test("a package the layer adds outside that closure counts as the layer's", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.isFrameworkPackage("@rescript/runtime")).toBe(true);
+  });
   globalThis.test("framework packages are starting points, not walked", () => {
     let packageDirs = Object.fromEntries([[
         "@reventlessdev/reventless-aws",