@ts-cloud/core 0.3.1 → 0.4.1

package/dist/index.js

@@ -25170,7 +25170,8 @@ var cloud_config_schema_default = {
           type: "object",
           description: "Serverless application manifest (Laravel-Vapor-equivalent). Defining this opts the environment into the serverless app deploy pipeline (http/queue/cli Lambda functions, assets, build/deploy hooks).",
           properties: {
-            runtime: { type: "string", description: "Lambda runtime (e.g. nodejs20.x, provided.al2023)" },
+            runtime: { type: "string", description: "Lambda runtime override (usually derived from kind + runtimeVersion)" },
+            runtimeVersion: { type: "string", description: "Node major (18/20/22 managed, 24+ custom layer) or Bun release for node/bun apps" },
             kind: { type: "string", enum: ["node", "bun", "php"], description: "Application kind (drives packaging + runtime)" },
             entry: { type: "string", description: "Entry file exporting the request handler" },
             memory: { type: "number", description: "HTTP function memory in MB" },
@@ -45281,7 +45282,7 @@ async function packageServerlessApp(opts) {
     opts.onStep?.("bundling application");
     const result = await Bun.build({
       entrypoints: [bootstrapPath],
-      target: "node",
+      target: app.kind === "bun" ? "bun" : "node",
       format: "esm",
       minify: false,
       sourcemap: "none"
@@ -45312,6 +45313,57 @@ ${logs}`);
     rmSync(stage, { recursive: true, force: true });
   }
 }
+// src/serverless/runtime-resolve.ts
+var MANAGED_NODE_VERSIONS = ["18", "20", "22"];
+function normalizeNodeVersion(v) {
+  if (!v)
+    return "22";
+  const m = String(v).match(/(\d+)/);
+  return m ? m[1] : "22";
+}
+function resolveServerlessRuntime(app) {
+  const kind = app.kind ?? "node";
+  if (kind === "php") {
+    return {
+      lambdaRuntime: "provided.al2023",
+      kind: "php",
+      version: app.phpVersion ?? "8.3",
+      usesLayer: true,
+      layerKind: "php",
+      layerEnvVar: "TSCLOUD_PHP_LAYER_ARN"
+    };
+  }
+  if (kind === "bun") {
+    return {
+      lambdaRuntime: "provided.al2023",
+      kind: "bun",
+      version: app.runtimeVersion ?? "latest",
+      usesLayer: true,
+      layerKind: "bun",
+      layerEnvVar: "TSCLOUD_BUN_LAYER_ARN"
+    };
+  }
+  const version = normalizeNodeVersion(app.runtimeVersion);
+  const explicitProvided = app.runtime === "provided.al2023";
+  const managed = !explicitProvided && MANAGED_NODE_VERSIONS.includes(version);
+  if (managed) {
+    return {
+      lambdaRuntime: app.runtime && app.runtime.startsWith("nodejs") ? app.runtime : `nodejs${version}.x`,
+      kind: "node",
+      version,
+      usesLayer: false
+    };
+  }
+  return {
+    lambdaRuntime: "provided.al2023",
+    kind: "node",
+    version,
+    usesLayer: true,
+    layerKind: "node",
+    layerEnvVar: "TSCLOUD_NODE_LAYER_ARN"
+  };
+}
+
 // src/serverless/composer.ts
 function resolveQueueNames(app, slug, env) {
   if (app.queues === false)
@@ -45326,7 +45378,7 @@ function resolveQueueNames(app, slug, env) {
 function composeServerlessAppTemplate(opts) {
   const { app, environment, handlers } = opts;
   const slug = opts.config.project.slug;
-  const runtime = app.runtime ?? "nodejs20.x";
+  const runtime = resolveServerlessRuntime(app).lambdaRuntime;
   const architecture = app.architecture ?? "x86_64";
   const region = opts.config.project.region;
   const functionNames = {
@@ -45951,6 +46003,84 @@ COPY app/ \${LAMBDA_TASK_ROOT}/
 CMD [ "index.http" ]
 `;
 }
+// src/serverless/runtimes/index.ts
+import { execFileSync } from "node:child_process";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync4, rmSync as rmSync2 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname as dirname3, join as join7 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function assetsDir() {
+  return dirname3(fileURLToPath2(import.meta.url));
+}
+function sharedRuntimeLoop() {
+  return readFileSync4(join7(assetsDir(), "runtime.mjs"), "utf-8");
+}
+function bootstrap(kind) {
+  return readFileSync4(join7(assetsDir(), `${kind}-bootstrap`), "utf-8");
+}
+function buildNodeRuntimeLayerZip(options) {
+  const architecture = options.architecture ?? "x86_64";
+  const nodeArch = architecture === "arm64" ? "arm64" : "x64";
+  const version = options.version.replace(/^v/, "");
+  const step = options.onStep ?? (() => {});
+  const stage = mkdtempSync2(join7(tmpdir2(), "tscloud-node-layer-"));
+  try {
+    const exact = version.includes(".") ? version : resolveLatestNode(version);
+    const dir = `node-v${exact}-linux-${nodeArch}`;
+    const url = `https://nodejs.org/dist/v${exact}/${dir}.tar.xz`;
+    step(`downloading Node ${exact} (${architecture})`);
+    const tar = join7(stage, "node.tar.xz");
+    fetchToFile(url, tar);
+    step("extracting node binary");
+    execFileSync("tar", ["-xf", tar, "-C", stage, `${dir}/bin/node`], { stdio: "inherit" });
+    const nodeBin = readFileSync4(join7(stage, dir, "bin", "node"));
+    step("packaging layer");
+    const entries = [
+      { name: "bootstrap", data: bootstrap("node"), mode: 493 },
+      { name: "runtime.mjs", data: sharedRuntimeLoop(), mode: 420 },
+      { name: "bin/node", data: nodeBin, mode: 493 }
+    ];
+    return { zip: createZip(entries), architecture, version: exact, fileCount: entries.length };
+  } finally {
+    rmSync2(stage, { recursive: true, force: true });
+  }
+}
+function buildBunRuntimeLayerZip(options) {
+  const architecture = options.architecture ?? "x86_64";
+  const bunArch = architecture === "arm64" ? "bun-linux-aarch64" : "bun-linux-x64";
+  const version = options.version === "latest" ? "" : options.version.replace(/^v/, "");
+  const step = options.onStep ?? (() => {});
+  const stage = mkdtempSync2(join7(tmpdir2(), "tscloud-bun-layer-"));
+  try {
+    const url = version ? `https://github.com/oven-sh/bun/releases/download/bun-v${version}/${bunArch}.zip` : `https://github.com/oven-sh/bun/releases/latest/download/${bunArch}.zip`;
+    step(`downloading Bun ${version || "latest"} (${architecture})`);
+    const zipPath = join7(stage, "bun.zip");
+    fetchToFile(url, zipPath);
+    step("extracting bun binary");
+    execFileSync("unzip", ["-o", "-q", zipPath, "-d", stage], { stdio: "inherit" });
+    const bunBin = readFileSync4(join7(stage, bunArch, "bun"));
+    step("packaging layer");
+    const entries = [
+      { name: "bootstrap", data: bootstrap("bun"), mode: 493 },
+      { name: "runtime.mjs", data: sharedRuntimeLoop(), mode: 420 },
+      { name: "bin/bun", data: bunBin, mode: 493 }
+    ];
+    return { zip: createZip(entries), architecture, version: version || "latest", fileCount: entries.length };
+  } finally {
+    rmSync2(stage, { recursive: true, force: true });
+  }
+}
+function fetchToFile(url, dest) {
+  execFileSync("curl", ["-fsSL", "-o", dest, url], { stdio: ["ignore", "ignore", "inherit"] });
+}
+function resolveLatestNode(major) {
+  const indexJson = execFileSync("curl", ["-fsSL", "https://nodejs.org/dist/index.json"], { encoding: "utf-8" });
+  const releases = JSON.parse(indexJson);
+  const match = releases.find((r) => r.version.startsWith(`v${major}.`));
+  if (!match)
+    throw new Error(`No Node release found for major version ${major}`);
+  return match.version.replace(/^v/, "");
+}
 // src/serverless/runtime/adapter.ts
 function resolveApp(mod) {
   const m = mod;
@@ -46103,15 +46233,15 @@ clear_env = no
 `;
 }
 // src/serverless-php/runtime-assets.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname3, join as join7 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-function assetsDir() {
-  return join7(dirname3(fileURLToPath2(import.meta.url)), "runtime-assets");
+import { readFileSync as readFileSync5 } from "node:fs";
+import { dirname as dirname4, join as join8 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function assetsDir2() {
+  return join8(dirname4(fileURLToPath3(import.meta.url)), "runtime-assets");
 }
 function phpRuntimeLayerAssets() {
-  const dir = assetsDir();
-  const read = (f) => readFileSync4(join7(dir, f), "utf-8");
+  const dir = assetsDir2();
+  const read = (f) => readFileSync5(join8(dir, f), "utf-8");
   return [
     { path: "bootstrap", contents: read("bootstrap"), mode: 493 },
     { path: "tscloud/runtime.php", contents: read("runtime.php"), mode: 420 },
@@ -46147,13 +46277,13 @@ var LARAVEL_SERVERLESS_BUILD_STEPS = [
   "php artisan view:cache"
 ];
 // src/serverless-php/layer-build.ts
-import { execFileSync } from "node:child_process";
-import { existsSync as existsSync5, mkdtempSync as mkdtempSync2, readdirSync as readdirSync5, readFileSync as readFileSync5, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8, relative as relative2 } from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync5, mkdtempSync as mkdtempSync3, readdirSync as readdirSync5, readFileSync as readFileSync6, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join9, relative as relative2 } from "node:path";
 function* walk(dir) {
   for (const entry of readdirSync5(dir)) {
-    const full = join8(dir, entry);
+    const full = join9(dir, entry);
     if (statSync3(full).isDirectory())
       yield* walk(full);
     else
@@ -46164,19 +46294,19 @@ function buildPhpRuntimeLayerZip(options = {}) {
   const architecture = options.architecture ?? "x86_64";
   const platform = options.platform ?? (architecture === "arm64" ? "linux/arm64" : "linux/amd64");
   const step = options.onStep ?? (() => {});
-  const stage = mkdtempSync2(join8(tmpdir2(), "tscloud-php-layer-"));
+  const stage = mkdtempSync3(join9(tmpdir3(), "tscloud-php-layer-"));
   const imageTag = "tscloud-php-layer:build";
   try {
-    writeFileSync4(join8(stage, "Dockerfile"), generatePhpLayerDockerfile(options));
+    writeFileSync5(join9(stage, "Dockerfile"), generatePhpLayerDockerfile(options));
     step("Building PHP runtime image (docker)");
-    execFileSync("docker", ["build", "--platform", platform, "-t", imageTag, stage], { stdio: "inherit" });
+    execFileSync2("docker", ["build", "--platform", platform, "-t", imageTag, stage], { stdio: "inherit" });
     step("Extracting /opt from image");
-    const cid = execFileSync("docker", ["create", "--platform", platform, imageTag], { encoding: "utf-8" }).trim();
-    const optDir = join8(stage, "opt");
+    const cid = execFileSync2("docker", ["create", "--platform", platform, imageTag], { encoding: "utf-8" }).trim();
+    const optDir = join9(stage, "opt");
     try {
-      execFileSync("docker", ["cp", `${cid}:/opt/.`, optDir], { stdio: "inherit" });
+      execFileSync2("docker", ["cp", `${cid}:/opt/.`, optDir], { stdio: "inherit" });
     } finally {
-      execFileSync("docker", ["rm", cid], { stdio: "ignore" });
+      execFileSync2("docker", ["rm", cid], { stdio: "ignore" });
     }
     if (!existsSync5(optDir))
       throw new Error("layer build produced no /opt directory");
@@ -46184,7 +46314,7 @@ function buildPhpRuntimeLayerZip(options = {}) {
     for (const file of walk(optDir)) {
       const rel = relative2(optDir, file).replace(/\\/g, "/");
       const mode = statSync3(file).mode & 73 ? 493 : 420;
-      entries.push({ name: rel, data: readFileSync5(file), mode });
+      entries.push({ name: rel, data: readFileSync6(file), mode });
     }
     step("Injecting runtime assets");
     const assetPaths = new Set(phpRuntimeLayerAssets().map((a) => a.path));
@@ -46196,14 +46326,14 @@ function buildPhpRuntimeLayerZip(options = {}) {
     const zip2 = createZip(filtered);
     return { zip: zip2, architecture, fileCount: filtered.length };
   } finally {
-    rmSync2(stage, { recursive: true, force: true });
+    rmSync3(stage, { recursive: true, force: true });
   }
 }
 // src/serverless-php/package-php.ts
 import { execSync as execSync2 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
-import { readdirSync as readdirSync6, readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
-import { join as join9, relative as relative3, resolve as resolve2 } from "node:path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync7, statSync as statSync4 } from "node:fs";
+import { join as join10, relative as relative3, resolve as resolve2 } from "node:path";
 var PHP_DEFAULT_EXCLUDES = [
   ".git",
   ".github",
@@ -46224,7 +46354,7 @@ function isExcluded(rel, excludes) {
 }
 function* walk2(dir, root, excludes) {
   for (const entry of readdirSync6(dir)) {
-    const full = join9(dir, entry);
+    const full = join10(dir, entry);
     const rel = relative3(root, full).replace(/\\/g, "/");
     if (isExcluded(rel, excludes))
       continue;
@@ -46251,7 +46381,7 @@ function collectPhpAppEntries(projectRoot, exclude = []) {
   for (const file of walk2(root, root, excludes)) {
     const rel = relative3(root, file).replace(/\\/g, "/");
     const executable = (statSync4(file).mode & 73) !== 0;
-    entries.push({ name: rel, data: readFileSync6(file), mode: executable ? 493 : 420 });
+    entries.push({ name: rel, data: readFileSync7(file), mode: executable ? 493 : 420 });
   }
   return entries;
 }
@@ -46743,6 +46873,7 @@ export {
   stackDependencyManager,
   signRequestAsync,
   signRequest,
+  sharedRuntimeLoop,
   sha256,
   serviceMeshManager,
   sequence,
@@ -46763,6 +46894,7 @@ export {
   resolveSiteStackName,
   resolveSiteResourceName,
   resolveSiteBucketName,
+  resolveServerlessRuntime,
   resolveServerlessAssetBucketName,
   resolveServerlessArtifactBucketName,
   resolveServerlessAppStackName,
@@ -46952,7 +47084,9 @@ export {
   canaryManager,
   buildPhpRuntimeLayerZip,
   buildOptimizationManager,
+  buildNodeRuntimeLayerZip,
   buildCloudFormationTemplate,
+  buildBunRuntimeLayerZip,
   bounceComplaintHandler,
   blueGreenManager,
   batchProcessingManager,
@@ -47033,6 +47167,7 @@ export {
   MigrationManager,
   MetricsManager,
   Messaging,
+  MANAGED_NODE_VERSIONS,
   LogsManager,
   LambdaVersionsManager,
   LambdaVPCManager,

package/dist/serverless/index.d.ts

@@ -7,4 +7,6 @@ export * from './bootstrap';
 export * from './package';
 export * from './composer';
 export * from './app-image';
+export * from './runtime-resolve';
+export * from './runtimes';
 export * from './runtime/adapter';

package/dist/serverless/runtime-resolve.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Resolves the Lambda runtime for a serverless app from its `kind` +
+ * `runtimeVersion`, deciding between an AWS **managed** Node runtime (zero
+ * config, no layer) and a **custom** `provided.al2023` runtime backed by a
+ * ts-cloud-built layer (binary + bootstrap + Runtime API loop).
+ *
+ * This unifies all three runtimes under one model: PHP, Bun, and newer Node
+ * versions all run on `provided.al2023` with a ts-cloud layer, while common Node
+ * versions stay on the managed runtime for simplicity.
+ */
+import type { ServerlessAppConfig } from '../types';
+/** Node major versions AWS provides a managed runtime for (`nodejs{N}.x`). */
+export declare const MANAGED_NODE_VERSIONS: readonly ["18", "20", "22"];
+export type RuntimeLayerKind = 'node' | 'bun' | 'php';
+export interface ResolvedRuntime {
+    /** The Lambda `Runtime` value (e.g. `nodejs22.x` or `provided.al2023`). */
+    lambdaRuntime: string;
+    /** Application kind. */
+    kind: 'node' | 'bun' | 'php';
+    /** Resolved version string (node major / bun release / php version). */
+    version: string;
+    /** Whether a ts-cloud custom runtime layer is required. */
+    usesLayer: boolean;
+    /** Which layer to build/attach when {@link usesLayer}. */
+    layerKind?: RuntimeLayerKind;
+    /** Env var name the orchestrator reads for a fallback layer ARN. */
+    layerEnvVar?: string;
+}
+/**
+ * Resolve the runtime for an app. Honors an explicit `runtime` override; falls
+ * back to deriving from `kind`/`runtimeVersion`.
+ */
+export declare function resolveServerlessRuntime(app: ServerlessAppConfig): ResolvedRuntime;

package/dist/serverless/runtime-resolve.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/serverless/runtimes/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Unified custom-runtime (`provided.al2023`) layer builders for Node and Bun.
+ *
+ * Both ship the same shape as the PHP runtime layer — a binary + a `bootstrap`
+ * entrypoint + the shared {@link runtime.mjs} Runtime API loop — so newer Node
+ * versions (e.g. 24, beyond AWS's managed runtimes) and Bun run on Lambda the
+ * same way Laravel/PHP does. Unlike the PHP layer these need no Docker: the
+ * official binary is downloaded and zipped directly.
+ */
+export type RuntimeArch = 'x86_64' | 'arm64';
+/** The shared Runtime API loop source (bundled into every node/bun layer). */
+export declare function sharedRuntimeLoop(): string;
+export interface BuildRuntimeLayerOptions {
+    /** Runtime version (Node major like '24', or a Bun release like '1.3.13'). */
+    version: string;
+    /** Target architecture. @default 'x86_64' */
+    architecture?: RuntimeArch;
+    /** Progress callback. */
+    onStep?: (message: string) => void;
+}
+export interface RuntimeLayerArtifact {
+    zip: Buffer;
+    architecture: RuntimeArch;
+    version: string;
+    fileCount: number;
+}
+/**
+ * Build the Node custom-runtime layer (any Node version, incl. those without an
+ * AWS managed runtime such as 24). Downloads the official linux build and
+ * assembles `bootstrap` + `runtime.mjs` + `bin/node`.
+ */
+export declare function buildNodeRuntimeLayerZip(options: BuildRuntimeLayerOptions): RuntimeLayerArtifact;
+/**
+ * Build the Bun custom-runtime layer. Downloads the pinned Bun release and
+ * assembles `bootstrap` + `runtime.mjs` + `bin/bun`.
+ */
+export declare function buildBunRuntimeLayerZip(options: BuildRuntimeLayerOptions): RuntimeLayerArtifact;

package/dist/serverless/runtimes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -1422,11 +1422,24 @@ export interface FunctionConfig {
  */
 export interface ServerlessAppConfig {
     /**
-     * Lambda runtime shared by all three functions.
-     * Use `provided.al2023` for PHP (custom runtime layer) or Bun custom runtimes.
-     * @default 'nodejs20.x'
+     * Explicit Lambda runtime override. Usually you don't set this — it's derived
+     * from {@link kind} + {@link runtimeVersion}:
+     * - `node` on a managed version → `nodejs{18,20,22}.x`
+     * - `node` on a non-managed version (e.g. 24), `bun`, or `php` →
+     *   `provided.al2023` with a ts-cloud-built custom runtime layer
+     *
+     * Set this to force a specific value (e.g. `provided.al2023` to run Node on a
+     * custom layer even for a managed version).
+     * @default derived from kind/runtimeVersion
+     */
+    runtime?: 'nodejs18.x' | 'nodejs20.x' | 'nodejs22.x' | 'provided.al2023' | (string & {});
+    /**
+     * Runtime version for `node`/`bun` apps (PHP uses {@link phpVersion}).
+     * - node: '18' | '20' | '22' (managed) or '24'+ (custom provided.al2023 layer)
+     * - bun:  a Bun release, e.g. '1.3.13' (always a custom provided.al2023 layer)
+     * @default node '22', bun the layer's pinned default
      */
-    runtime?: 'nodejs20.x' | 'nodejs22.x' | 'provided.al2023' | (string & {});
+    runtimeVersion?: string;
     /**
      * Application kind. Drives packaging + runtime selection.
      * - `node` / `bun`: bundle a JS/TS handler artifact

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-cloud/core",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "type": "module",
   "description": "Core CloudFormation generation library for ts-cloud",
   "author": "Chris Breuer <chris@stacksjs.com>",
@@ -31,7 +31,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ts-cloud/aws-types": "0.3.1"
+    "@ts-cloud/aws-types": "0.4.1"
   },
   "devDependencies": {
     "typescript": "^5.9.3"