effortless-aws 0.1.1 → 0.2.0

package/dist/{chunk-I5TS7O5S.js → chunk-7JVA4742.js}

@@ -99,6 +99,21 @@ var createTableClient = (tableName) => {
   };
 };
 
+// src/runtime/platform-types.ts
+var ENV_PLATFORM_TABLE = "EFF_PLATFORM_TABLE";
+var DEFAULT_TTL_SECONDS = 7 * 24 * 60 * 60;
+var truncateForStorage = (value, maxLength = 4096) => {
+  if (value === void 0 || value === null) return value;
+  const str = typeof value === "string" ? value : JSON.stringify(value);
+  if (str.length <= maxLength) return value;
+  return str.slice(0, maxLength) + "...[truncated]";
+};
+var dateBucket = (date = /* @__PURE__ */ new Date()) => date.toISOString().slice(0, 10);
+var computeTtl = (ttlSeconds = DEFAULT_TTL_SECONDS) => Math.floor(Date.now() / 1e3) + ttlSeconds;
+
+// src/runtime/handler-utils.ts
+import { randomUUID } from "crypto";
+
 // src/runtime/ssm-client.ts
 import { SSM } from "@aws-sdk/client-ssm";
 var client = null;
@@ -120,6 +135,89 @@ var getParameters = async (names) => {
   return map;
 };
 
+// src/runtime/platform-client.ts
+import { DynamoDB as DynamoDB2 } from "@aws-sdk/client-dynamodb";
+import { marshall as marshall2, unmarshall as unmarshall2 } from "@aws-sdk/util-dynamodb";
+var createPlatformClient = () => {
+  const tableName = process.env[ENV_PLATFORM_TABLE];
+  if (!tableName) return void 0;
+  let client2 = null;
+  const getClient2 = () => client2 ??= new DynamoDB2({});
+  const appendToList = async (handlerName, handlerType, listAttr, entry) => {
+    const sk = `EXEC#${dateBucket()}`;
+    try {
+      await getClient2().updateItem({
+        TableName: tableName,
+        Key: marshall2({ pk: `HANDLER#${handlerName}`, sk }),
+        UpdateExpression: "SET #list = list_append(if_not_exists(#list, :empty), :entry), #type = :type, #hn = :hn, #ht = :ht, #ttl = :ttl",
+        ExpressionAttributeNames: {
+          "#list": listAttr,
+          "#type": "type",
+          "#hn": "handlerName",
+          "#ht": "handlerType",
+          "#ttl": "ttl"
+        },
+        ExpressionAttributeValues: marshall2(
+          {
+            ":entry": [entry],
+            ":empty": [],
+            ":type": "execution-log",
+            ":hn": handlerName,
+            ":ht": handlerType,
+            ":ttl": computeTtl()
+          },
+          { removeUndefinedValues: true }
+        )
+      });
+    } catch (err) {
+      console.error("[effortless] Failed to write platform record:", err);
+    }
+  };
+  return {
+    tableName,
+    async appendExecution(handlerName, handlerType, entry) {
+      await appendToList(handlerName, handlerType, "executions", entry);
+    },
+    async appendError(handlerName, handlerType, entry) {
+      await appendToList(handlerName, handlerType, "errors", entry);
+    },
+    async get(pk, sk) {
+      const result = await getClient2().getItem({
+        TableName: tableName,
+        Key: marshall2({ pk, sk })
+      });
+      return result.Item ? unmarshall2(result.Item) : void 0;
+    },
+    async query(pk, skPrefix) {
+      const names = { "#pk": "pk" };
+      const values = { ":pk": pk };
+      let keyCondition = "#pk = :pk";
+      if (skPrefix) {
+        names["#sk"] = "sk";
+        values[":sk"] = skPrefix;
+        keyCondition += " AND begins_with(#sk, :sk)";
+      }
+      const result = await getClient2().query({
+        TableName: tableName,
+        KeyConditionExpression: keyCondition,
+        ExpressionAttributeNames: names,
+        ExpressionAttributeValues: marshall2(values, { removeUndefinedValues: true })
+      });
+      return (result.Items ?? []).map((item) => unmarshall2(item));
+    },
+    async put(entity) {
+      try {
+        await getClient2().putItem({
+          TableName: tableName,
+          Item: marshall2(entity, { removeUndefinedValues: true })
+        });
+      } catch (err) {
+        console.error("[effortless] Failed to write platform record:", err);
+      }
+    }
+  };
+};
+
 // src/runtime/handler-utils.ts
 var ENV_TABLE_PREFIX = "EFF_TABLE_";
 var ENV_PARAM_PREFIX = "EFF_PARAM_";
@@ -155,9 +253,58 @@ var buildParams = async (params) => {
   }
   return result;
 };
+var createHandlerRuntime = (handler, handlerType) => {
+  const platform = createPlatformClient();
+  const handlerName = process.env.EFF_HANDLER ?? "unknown";
+  let ctx = null;
+  let resolvedDeps;
+  let resolvedParams = null;
+  const getDeps = () => resolvedDeps ??= buildDeps(handler.deps);
+  const getParams = async () => {
+    if (resolvedParams !== null) return resolvedParams;
+    resolvedParams = await buildParams(handler.params);
+    return resolvedParams;
+  };
+  const getCtx = async () => {
+    if (ctx !== null) return ctx;
+    if (handler.context) {
+      const params = await getParams();
+      ctx = params ? await handler.context({ params }) : await handler.context();
+    }
+    return ctx;
+  };
+  const commonArgs = async () => {
+    const args = {};
+    if (handler.context) args.ctx = await getCtx();
+    const deps = getDeps();
+    if (deps) args.deps = deps;
+    const params = await getParams();
+    if (params) args.params = params;
+    return args;
+  };
+  const logExecution = (startTime, input, output) => {
+    platform?.appendExecution(handlerName, handlerType, {
+      id: randomUUID(),
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      ms: Date.now() - startTime,
+      in: input,
+      out: truncateForStorage(output)
+    });
+  };
+  const logError = (startTime, input, error) => {
+    platform?.appendError(handlerName, handlerType, {
+      id: randomUUID(),
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      ms: Date.now() - startTime,
+      in: input,
+      err: error instanceof Error ? error.message : String(error)
+    });
+  };
+  return { commonArgs, logExecution, logError, handlerName };
+};
 
 export {
   createTableClient,
-  buildDeps,
-  buildParams
+  truncateForStorage,
+  createHandlerRuntime
 };

package/dist/cli/index.js

@@ -69937,15 +69937,39 @@ var waitForTableActive = (tableName) => Effect_exports.gen(function* () {
   }
   return yield* Effect_exports.fail(new Error(`Timeout waiting for table ${tableName} to become active`));
 });
+var ensureTimeToLive = (tableName, attributeName) => Effect_exports.gen(function* () {
+  const current = yield* dynamodb_exports.make("describe_time_to_live", {
+    TableName: tableName
+  });
+  const status2 = current.TimeToLiveDescription?.TimeToLiveStatus;
+  const currentAttr = current.TimeToLiveDescription?.AttributeName;
+  if (status2 === "ENABLED" && currentAttr === attributeName) {
+    return;
+  }
+  if (status2 === "ENABLING") {
+    yield* Effect_exports.logInfo(`TTL is being enabled on ${tableName}, waiting...`);
+    yield* Effect_exports.sleep(5e3);
+    return;
+  }
+  yield* Effect_exports.logInfo(`Enabling TTL on ${tableName} (attribute: ${attributeName})`);
+  yield* dynamodb_exports.make("update_time_to_live", {
+    TableName: tableName,
+    TimeToLiveSpecification: {
+      Enabled: true,
+      AttributeName: attributeName
+    }
+  });
+});
 var ensureTable = (input) => Effect_exports.gen(function* () {
-  const { name, pk, sk, billingMode = "PAY_PER_REQUEST", streamView = "NEW_AND_OLD_IMAGES", tags: tags2 } = input;
+  const { name, pk, sk, billingMode = "PAY_PER_REQUEST", streamView = "NEW_AND_OLD_IMAGES", tags: tags2, ttlAttribute } = input;
   const existingTable = yield* dynamodb_exports.make("describe_table", { TableName: name }).pipe(
-    Effect_exports.map((result) => result.Table),
+    Effect_exports.map((result2) => result2.Table),
     Effect_exports.catchIf(
       (error4) => error4 instanceof dynamodb_exports.DynamoDBError && error4.cause.name === "ResourceNotFoundException",
       () => Effect_exports.succeed(void 0)
     )
   );
+  let result;
   if (!existingTable) {
     yield* Effect_exports.logInfo(`Creating table ${name}...`);
     const keySchema = [
@@ -69967,34 +69991,40 @@ var ensureTable = (input) => Effect_exports.gen(function* () {
       Tags: tags2 ? toAwsTagList(tags2) : void 0
     });
     const table3 = yield* waitForTableActive(name);
-    return {
+    result = {
       tableArn: table3.TableArn,
       streamArn: table3.LatestStreamArn
     };
+  } else {
+    yield* Effect_exports.logInfo(`Table ${name} already exists`);
+    if (tags2) {
+      yield* dynamodb_exports.make("tag_resource", {
+        ResourceArn: existingTable.TableArn,
+        Tags: toAwsTagList(tags2)
+      });
+    }
+    if (!existingTable.StreamSpecification?.StreamEnabled) {
+      yield* Effect_exports.logInfo(`Enabling stream on table ${name}...`);
+      yield* dynamodb_exports.make("update_table", {
+        TableName: name,
+        StreamSpecification: streamViewToSpec(streamView)
+      });
+      const table3 = yield* waitForTableActive(name);
+      result = {
+        tableArn: table3.TableArn,
+        streamArn: table3.LatestStreamArn
+      };
+    } else {
+      result = {
+        tableArn: existingTable.TableArn,
+        streamArn: existingTable.LatestStreamArn
+      };
+    }
   }
-  yield* Effect_exports.logInfo(`Table ${name} already exists`);
-  if (tags2) {
-    yield* dynamodb_exports.make("tag_resource", {
-      ResourceArn: existingTable.TableArn,
-      Tags: toAwsTagList(tags2)
-    });
-  }
-  if (!existingTable.StreamSpecification?.StreamEnabled) {
-    yield* Effect_exports.logInfo(`Enabling stream on table ${name}...`);
-    yield* dynamodb_exports.make("update_table", {
-      TableName: name,
-      StreamSpecification: streamViewToSpec(streamView)
-    });
-    const table3 = yield* waitForTableActive(name);
-    return {
-      tableArn: table3.TableArn,
-      streamArn: table3.LatestStreamArn
-    };
+  if (ttlAttribute) {
+    yield* ensureTimeToLive(name, ttlAttribute);
   }
-  return {
-    tableArn: existingTable.TableArn,
-    streamArn: existingTable.LatestStreamArn
-  };
+  return result;
 });
 var ensureEventSourceMapping = (input) => Effect_exports.gen(function* () {
   const { functionArn, streamArn, batchSize = 100, batchWindow, startingPosition = "LATEST" } = input;
@@ -70162,10 +70192,10 @@ var computeLockfileHash = (projectDir) => Effect_exports.gen(function* () {
   if (prodDeps.length === 0) {
     return yield* Effect_exports.fail(new Error("No production dependencies"));
   }
-  const { packages: allPackages } = collectTransitiveDeps(projectDir, prodDeps);
+  const { packages: allPackages, resolvedPaths } = collectTransitiveDeps(projectDir, prodDeps);
   const packageVersions = [];
   for (const pkgName of Array.from(allPackages).sort()) {
-    const pkgPath = findInPnpmStore(projectDir, pkgName) ?? getPackageRealPath(projectDir, pkgName);
+    const pkgPath = resolvedPaths.get(pkgName) ?? findInPnpmStore(projectDir, pkgName) ?? getPackageRealPath(projectDir, pkgName);
     if (pkgPath) {
       const version = getPackageVersion(pkgPath);
       if (version) {
@@ -70231,7 +70261,7 @@ var findInPnpmStore = (projectDir, pkgName) => {
   }
   return null;
 };
-var collectTransitiveDeps = (projectDir, rootDeps, searchPath = path4.join(projectDir, "node_modules"), visited = /* @__PURE__ */ new Set(), warnings = []) => {
+var collectTransitiveDeps = (projectDir, rootDeps, searchPath = path4.join(projectDir, "node_modules"), visited = /* @__PURE__ */ new Set(), resolvedPaths = /* @__PURE__ */ new Map(), warnings = []) => {
   const rootNodeModules = path4.join(projectDir, "node_modules");
   for (const dep of rootDeps) {
     if (visited.has(dep)) continue;
@@ -70262,44 +70292,63 @@ var collectTransitiveDeps = (projectDir, rootDeps, searchPath = path4.join(proje
       continue;
     }
     visited.add(dep);
+    resolvedPaths.set(dep, realPath2);
     const pkgDeps = getPackageDeps(realPath2);
     if (pkgDeps.length > 0) {
       const isScoped = dep.startsWith("@");
       const pkgNodeModules = isScoped ? path4.dirname(path4.dirname(realPath2)) : path4.dirname(realPath2);
-      collectTransitiveDeps(projectDir, pkgDeps, pkgNodeModules, visited, warnings);
+      collectTransitiveDeps(projectDir, pkgDeps, pkgNodeModules, visited, resolvedPaths, warnings);
     }
   }
-  return { packages: visited, warnings };
+  return { packages: visited, resolvedPaths, warnings };
 };
 var isAwsRuntime = (pkg) => pkg.startsWith("@aws-sdk/") || pkg.startsWith("@smithy/");
 var collectLayerPackages = (projectDir, dependencies) => {
-  if (dependencies.length === 0) return { packages: [], warnings: [] };
-  const { packages, warnings } = collectTransitiveDeps(projectDir, dependencies);
+  if (dependencies.length === 0) return { packages: [], resolvedPaths: /* @__PURE__ */ new Map(), warnings: [] };
+  const { packages, resolvedPaths, warnings } = collectTransitiveDeps(projectDir, dependencies);
   let changed = true;
   while (changed) {
     changed = false;
     for (const pkg of [...packages]) {
       if (isAwsRuntime(pkg)) continue;
-      const pkgPath = findPackagePath(projectDir, pkg);
-      if (!pkgPath) continue;
-      const pkgDeps = getPackageDeps(pkgPath);
-      for (const dep of pkgDeps) {
-        if (!packages.has(dep) && !isAwsRuntime(dep)) {
-          packages.add(dep);
-          warnings.push(`Auto-added missing transitive dep: "${dep}" (required by "${pkg}")`);
-          changed = true;
+      const pkgPaths = /* @__PURE__ */ new Set();
+      const resolved = resolvedPaths.get(pkg);
+      if (resolved) pkgPaths.add(resolved);
+      const found = findPackagePath(projectDir, pkg);
+      if (found) pkgPaths.add(found);
+      if (pkgPaths.size === 0) continue;
+      for (const pkgPath of pkgPaths) {
+        const pkgDeps = getPackageDeps(pkgPath);
+        for (const dep of pkgDeps) {
+          if (!packages.has(dep) && !isAwsRuntime(dep)) {
+            packages.add(dep);
+            changed = true;
+            let depPath = findPackagePath(projectDir, dep);
+            if (!depPath) {
+              const isScoped = pkg.startsWith("@");
+              const parentNodeModules = isScoped ? path4.dirname(path4.dirname(pkgPath)) : path4.dirname(pkgPath);
+              const depInParent = path4.join(parentNodeModules, dep);
+              if (fsSync.existsSync(depInParent)) {
+                try {
+                  depPath = fsSync.realpathSync(depInParent);
+                } catch {
+                }
+              }
+            }
+            if (depPath) resolvedPaths.set(dep, depPath);
+          }
         }
       }
     }
   }
-  return { packages: Array.from(packages), warnings };
+  return { packages: Array.from(packages), resolvedPaths, warnings };
 };
 var findPackagePath = (projectDir, pkgName) => {
   const rootPath = getPackageRealPath(projectDir, pkgName);
   if (rootPath) return rootPath;
   return findInPnpmStore(projectDir, pkgName);
 };
-var createLayerZip = (projectDir, packages) => Effect_exports.async((resume2) => {
+var createLayerZip = (projectDir, packages, resolvedPaths) => Effect_exports.async((resume2) => {
   const chunks2 = [];
   const archive = archiver("zip", { zlib: { level: 9 } });
   const addedPaths = /* @__PURE__ */ new Set();
@@ -70313,7 +70362,7 @@ var createLayerZip = (projectDir, packages) => Effect_exports.async((resume2) =>
   })));
   archive.on("error", (err) => resume2(Effect_exports.fail(err)));
   for (const pkgName of packages) {
-    const realPath2 = findPackagePath(projectDir, pkgName);
+    const realPath2 = resolvedPaths?.get(pkgName) ?? findPackagePath(projectDir, pkgName);
     if (typeof realPath2 === "string" && realPath2.length > 0 && !addedPaths.has(realPath2)) {
       addedPaths.add(realPath2);
       includedPackages.push(pkgName);
@@ -70371,13 +70420,13 @@ var ensureLayer = (config2) => Effect_exports.gen(function* () {
     yield* Effect_exports.logInfo(`Layer ${layerName} with hash ${hash2} already exists (version ${existing.version})`);
     return existing;
   }
-  const { packages: allPackages, warnings: layerWarnings } = yield* Effect_exports.sync(() => collectLayerPackages(config2.projectDir, dependencies));
+  const { packages: allPackages, resolvedPaths, warnings: layerWarnings } = yield* Effect_exports.sync(() => collectLayerPackages(config2.projectDir, dependencies));
   for (const warning of layerWarnings) {
     yield* Effect_exports.logWarning(`[layer] ${warning}`);
   }
   yield* Effect_exports.logInfo(`Creating layer ${layerName} with ${allPackages.length} packages (hash: ${hash2})`);
   yield* Effect_exports.logDebug(`Layer packages: ${allPackages.join(", ")}`);
-  const { buffer: layerZip, includedPackages, skippedPackages } = yield* createLayerZip(config2.projectDir, allPackages);
+  const { buffer: layerZip, includedPackages, skippedPackages } = yield* createLayerZip(config2.projectDir, allPackages, resolvedPaths);
   if (skippedPackages.length > 0) {
     yield* Effect_exports.logWarning(`Skipped ${skippedPackages.length} packages (not found): ${skippedPackages.slice(0, 10).join(", ")}${skippedPackages.length > 10 ? "..." : ""}`);
   }
@@ -71083,6 +71132,31 @@ var mergeResolved = (deps, params) => {
   if (Object.keys(env2).length === 0) return void 0;
   return { depsEnv: env2, depsPermissions: permissions };
 };
+var PLATFORM_PERMISSIONS = [
+  "dynamodb:PutItem",
+  "dynamodb:GetItem",
+  "dynamodb:UpdateItem",
+  "dynamodb:Query"
+];
+var ensurePlatformTable = (project2, stage, region) => Effect_exports.gen(function* () {
+  const tableName = `${project2}-${stage}-platform`;
+  const tagCtx = { project: project2, stage, handler: "platform" };
+  yield* Effect_exports.logInfo(`Ensuring platform table: ${tableName}`);
+  yield* ensureTable({
+    name: tableName,
+    pk: { name: "pk", type: "string" },
+    sk: { name: "sk", type: "string" },
+    billingMode: "PAY_PER_REQUEST",
+    streamView: "NEW_AND_OLD_IMAGES",
+    tags: makeTags(tagCtx, "dynamodb"),
+    ttlAttribute: "ttl"
+  }).pipe(
+    Effect_exports.provide(
+      clients_exports.makeClients({ dynamodb: { region } })
+    )
+  );
+  return tableName;
+});
 var deployHttpHandlers = (ctx) => Effect_exports.gen(function* () {
   const results = [];
   for (const { file: file6, exports } of ctx.handlers) {
@@ -71100,12 +71174,17 @@ var deployHttpHandlers = (ctx) => Effect_exports.gen(function* () {
         resolveDeps(fn2.depsKeys, ctx.tableNameMap),
         resolveParams(fn2.paramEntries, ctx.input.project, stage)
       );
+      const withPlatform = {
+        depsEnv: { ...resolved?.depsEnv, ...ctx.platformEnv },
+        depsPermissions: [...resolved?.depsPermissions ?? [], ...ctx.platformPermissions]
+      };
       const { exportName, functionArn, config: config2 } = yield* deployLambda({
         input: deployInput,
         fn: fn2,
         ...ctx.layerArn ? { layerArn: ctx.layerArn } : {},
         ...ctx.external.length > 0 ? { external: ctx.external } : {},
-        ...resolved ? { depsEnv: resolved.depsEnv, depsPermissions: resolved.depsPermissions } : {}
+        depsEnv: withPlatform.depsEnv,
+        depsPermissions: withPlatform.depsPermissions
       }).pipe(
         Effect_exports.provide(
           clients_exports.makeClients({
@@ -71151,12 +71230,17 @@ var deployTableHandlers = (ctx) => Effect_exports.gen(function* () {
         resolveDeps(fn2.depsKeys, ctx.tableNameMap),
         resolveParams(fn2.paramEntries, ctx.input.project, stage)
       );
+      const withPlatform = {
+        depsEnv: { ...resolved?.depsEnv, ...ctx.platformEnv },
+        depsPermissions: [...resolved?.depsPermissions ?? [], ...ctx.platformPermissions]
+      };
       const result = yield* deployTableFunction({
         input: deployInput,
         fn: fn2,
         ...ctx.layerArn ? { layerArn: ctx.layerArn } : {},
         ...ctx.external.length > 0 ? { external: ctx.external } : {},
-        ...resolved ? { depsEnv: resolved.depsEnv, depsPermissions: resolved.depsPermissions } : {}
+        depsEnv: withPlatform.depsEnv,
+        depsPermissions: withPlatform.depsPermissions
       }).pipe(
         Effect_exports.provide(
           clients_exports.makeClients({
@@ -71191,6 +71275,9 @@ var deployProject = (input) => Effect_exports.gen(function* () {
     region: input.region,
     projectDir: input.projectDir
   });
+  const stage = resolveStage(input.stage);
+  const platformTableName = yield* ensurePlatformTable(input.project, stage, input.region);
+  const platformEnv = { EFF_PLATFORM_TABLE: platformTableName };
   let apiId;
   let apiUrl;
   if (totalHttpHandlers > 0) {
@@ -71221,14 +71308,18 @@ var deployProject = (input) => Effect_exports.gen(function* () {
     input,
     layerArn,
     external,
-    tableNameMap
+    tableNameMap,
+    platformEnv,
+    platformPermissions: PLATFORM_PERMISSIONS
   }) : [];
   const tableResults = yield* deployTableHandlers({
     handlers: tableHandlers,
     input,
     layerArn,
     external,
-    tableNameMap
+    tableNameMap,
+    platformEnv,
+    platformPermissions: PLATFORM_PERMISSIONS
   });
   if (apiUrl) {
     yield* Effect_exports.logInfo(`Deployment complete! API: ${apiUrl}`);
@@ -72105,31 +72196,6 @@ Deleted ${deleted} layer version(s).`);
     );
   })
 ).pipe(Command_exports.withDescription("Delete layer versions"));
-var findPackagePathForCopy = (projectDir, pkgName) => {
-  const rootPath = path11.join(projectDir, "node_modules", pkgName);
-  if (fs5.existsSync(rootPath)) {
-    try {
-      return fs5.realpathSync(rootPath);
-    } catch {
-    }
-  }
-  const pnpmDir = path11.join(projectDir, "node_modules", ".pnpm");
-  if (!fs5.existsSync(pnpmDir)) return null;
-  const pnpmPkgName = pkgName.replace("/", "+");
-  try {
-    const entries2 = fs5.readdirSync(pnpmDir);
-    for (const entry of entries2) {
-      if (entry.startsWith(pnpmPkgName + "@")) {
-        const pkgPath = path11.join(pnpmDir, entry, "node_modules", pkgName);
-        if (fs5.existsSync(pkgPath)) {
-          return fs5.realpathSync(pkgPath);
-        }
-      }
-    }
-  } catch {
-  }
-  return null;
-};
 var layersBuildCommand = Command_exports.make(
   "build",
   { output: outputOption, verbose: verboseOption },
@@ -72160,7 +72226,7 @@ var layersBuildCommand = Command_exports.make(
     );
     yield* Console_exports.log(`
 Lockfile hash: ${hash2}`);
-    const { packages: allPackages, warnings: layerWarnings } = yield* Effect_exports.sync(() => collectLayerPackages(projectDir, prodDeps));
+    const { packages: allPackages, resolvedPaths, warnings: layerWarnings } = yield* Effect_exports.sync(() => collectLayerPackages(projectDir, prodDeps));
     if (layerWarnings.length > 0) {
       yield* Console_exports.log(`
 Warnings (${layerWarnings.length}):`);
@@ -72179,7 +72245,7 @@ Collected ${allPackages.length} packages for layer`);
     let copied = 0;
     let skipped = 0;
     for (const pkgName of allPackages) {
-      const srcPath = findPackagePathForCopy(projectDir, pkgName);
+      const srcPath = resolvedPaths.get(pkgName) ?? null;
       if (!srcPath) {
         skipped++;
         if (verbose) {