@ts-cloud/core 0.2.26 → 0.3.0

package/dist/modules/cdn.d.ts

@@ -171,7 +171,7 @@ export declare class CDN {
      */
     static readonly EdgeFunctionTemplates: {
         /**
-         * Origin request handler for docs/VitePress routing
+         * Origin request handler for docs/BunPress routing
          */
         docsOriginRequest: string;
         /**

package/dist/modules/compute.d.ts

@@ -1073,6 +1073,7 @@ export declare class Compute {
             readonly java17: "java17";
             readonly go: "provided.al2023";
             readonly rust: "provided.al2023";
+            readonly bun: "provided.al2023";
         };
         /**
          * Common function configurations
@@ -1145,7 +1146,7 @@ export declare class Compute {
          *  - Multiple sites can share one EC2 instance
          */
         generateBunAppScript: (options: {
-            runtime?: "bun" | "node" | "deno";
+            runtime?: "bun" | "node" | "deno" | "php";
             runtimeVersion?: string;
             systemPackages?: string[];
             database?: "sqlite" | "mysql" | "postgres";
@@ -1269,7 +1270,13 @@ export declare class Compute {
         subnetId: string;
         instanceType?: string;
         imageId?: string;
-        keyName: string;
+        /**
+         * EC2 KeyName for SSH access. Optional — when omitted, no SSH key is
+         * associated with the instance and shell access goes via SSM Session
+         * Manager. The provided KeyName must already exist in EC2 or the
+         * launch fails with "key pair does not exist".
+         */
+        keyName?: string;
         domain?: string;
         userData?: string;
         allowedPorts?: number[];

package/dist/presets/dashboard.d.ts

@@ -0,0 +1,26 @@
+import type { SiteConfig } from '../types';
+/**
+ * The ts-cloud management dashboard (`@ts-cloud/ui`) as a deployable site —
+ * a static stx app served on the box by nginx, behind HTTP Basic auth whose
+ * password comes from an env value.
+ *
+ * Add it to your config's `sites` so `cloud deploy` builds + publishes it:
+ *
+ * ```ts
+ * sites: {
+ *   dashboard: createDashboardSite({ domain: 'dashboard.acme.com', password: process.env.TS_CLOUD_UI_PASSWORD }),
+ * }
+ * ```
+ */
+export declare function createDashboardSite(options: {
+    /** Domain the dashboard is served on (required for nginx vhost + SSL). */
+    domain: string;
+    /** Basic-auth password — typically `process.env.TS_CLOUD_UI_PASSWORD`. */
+    password?: string;
+    /** Basic-auth username. @default 'admin' */
+    username?: string;
+    /** Built UI output directory shipped to the box. @default 'ui/dist' */
+    root?: string;
+    /** Build command producing {@link root}. @default builds @ts-cloud/ui */
+    build?: string;
+}): SiteConfig;

package/dist/presets/index.d.ts

@@ -1,6 +1,7 @@
 export { createStaticSitePreset } from './static-site';
 export { createNodeJsServerPreset } from './nodejs-server';
 export { createNodeJsServerlessPreset } from './nodejs-serverless';
+export { createServerlessNodePreset } from './serverless-node';
 export { createFullStackAppPreset } from './fullstack-app';
 export { createApiBackendPreset } from './api-backend';
 export { createWordPressPreset } from './wordpress';
@@ -10,4 +11,6 @@ export { createRealtimeAppPreset } from './realtime-app';
 export { createDataPipelinePreset } from './data-pipeline';
 export { createMLApiPreset } from './ml-api';
 export { createTraditionalWebAppPreset } from './traditional-web-app';
+export { createLaravelPreset } from './laravel';
+export { createServerlessLaravelPreset } from './serverless-laravel';
 export { extendPreset, composePresets, createPreset, mergeInfrastructure, withMonitoring, withSecurity, withDatabase, withCache, withCDN, withQueue, } from './extend';

package/dist/presets/laravel.d.ts

@@ -0,0 +1,36 @@
+import type { CloudConfig, InstanceSize, PhpVersion } from '../types';
+/**
+ * Laravel Preset — a Forge-style single server.
+ *
+ * Provisions one box (Hetzner by default) running nginx + php-fpm + Composer,
+ * MySQL + Redis on the box, host firewall (UFW), automatic security updates,
+ * monitoring, and scheduled backups. The app is deployed from git into atomic
+ * zero-downtime releases, served over HTTPS via Let's Encrypt, with the queue
+ * worker and scheduler enabled.
+ */
+export declare function createLaravelPreset(options: {
+    name: string;
+    slug: string;
+    /** App domain (also used for the Let's Encrypt cert). */
+    domain?: string;
+    /** Git repository to deploy. */
+    repository: {
+        url: string;
+        branch?: string;
+        provider?: 'github' | 'gitlab' | 'bitbucket' | 'custom';
+    };
+    /** PHP version. @default '8.3' */
+    phpVersion?: PhpVersion;
+    /** Server size. @default 'small' */
+    size?: InstanceSize;
+    /** App database name. @default slug */
+    database?: string;
+    /** Database password (set via env in real configs). */
+    databasePassword?: string;
+    /** Contact email for Let's Encrypt. */
+    sslEmail?: string;
+    /** Deploy strategy. @default 'push' */
+    deployStrategy?: 'push' | 'tag';
+    /** Provider. @default 'hetzner' */
+    provider?: 'hetzner' | 'aws';
+}): Partial<CloudConfig>;

package/dist/presets/serverless-laravel.d.ts

@@ -0,0 +1,38 @@
+import type { CloudConfig } from '../types';
+/**
+ * Serverless Laravel preset — a true Laravel-Vapor clone running on AWS Lambda.
+ *
+ * Produces an `environments.<env>.app` manifest (kind: 'php') that the serverless
+ * deploy pipeline turns into three Lambda functions on the ts-cloud PHP runtime
+ * layer: HTTP via php-fpm (API Gateway v2), an SQS queue worker (one job per
+ * invocation), and a CLI function (EventBridge scheduler + artisan commands),
+ * plus a DynamoDB cache table and CDN-backed `public/` assets.
+ *
+ * Build hooks default to the Laravel artisan caching steps (config/route/event/
+ * view cache) since the Lambda filesystem is read-only at runtime; the deploy
+ * hook runs migrations. Install the `tscloud/serverless` composer package in the
+ * app for the SQS queue bridge (a `laravel/vapor-core` replacement).
+ *
+ * @example
+ * export default createServerlessLaravelPreset({
+ *   name: 'My App', slug: 'my-app', domain: 'my-app.com',
+ *   layers: ['arn:aws:lambda:us-east-1:123:layer:tscloud-php-83:1'],
+ * })
+ */
+export declare function createServerlessLaravelPreset(options: {
+    name: string;
+    slug: string;
+    domain?: string;
+    /** PHP runtime layer ARN(s). If omitted, set TSCLOUD_PHP_LAYER_ARN at deploy. */
+    layers?: string[];
+    phpVersion?: '8.1' | '8.2' | '8.3' | '8.4';
+    architecture?: 'x86_64' | 'arm64';
+    memory?: number;
+    /** Override build hooks (defaults to Laravel artisan caching). */
+    build?: string[];
+    /** Override deploy hooks (defaults to `migrate --force`). */
+    deploy?: string[];
+    cache?: 'dynamodb' | 'elasticache';
+    scheduler?: 'off' | 'on' | 'sub-minute';
+    region?: string;
+}): Partial<CloudConfig>;

package/dist/presets/serverless-node.d.ts

@@ -0,0 +1,36 @@
+import type { CloudConfig } from '../types';
+/**
+ * Serverless Node/Bun application preset (Laravel-Vapor-equivalent for JS/TS).
+ *
+ * Produces an `environments.<env>.app` manifest that the serverless deploy
+ * pipeline (`cloud deploy:serverless`) turns into three Lambda functions sharing
+ * one bundled artifact: HTTP (API Gateway v2), queue worker (SQS), and CLI
+ * (EventBridge scheduler + on-demand commands), plus a DynamoDB cache table and
+ * optional CDN-backed assets.
+ *
+ * @example
+ * export default createServerlessNodePreset({
+ *   name: 'My API', slug: 'my-api',
+ *   entry: 'src/server.ts', domain: 'api.example.com',
+ *   build: ['bun install', 'bun run build'],
+ *   deploy: ['migrate'],
+ * })
+ */
+export declare function createServerlessNodePreset(options: {
+    name: string;
+    slug: string;
+    entry: string;
+    domain?: string;
+    runtime?: 'nodejs20.x' | 'nodejs22.x';
+    memory?: number;
+    /** Build commands run locally before packaging. */
+    build?: string[];
+    /** Deploy commands run remotely after activation (e.g. migrations). */
+    deploy?: string[];
+    /** Static asset directory served via CloudFront (e.g. `public` or `dist`). */
+    assets?: string;
+    /** Queue names; defaults to a single `default` queue. */
+    queues?: boolean | Array<string | Record<string, number>>;
+    scheduler?: 'off' | 'on' | 'sub-minute';
+    region?: string;
+}): Partial<CloudConfig>;

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

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

package/dist/serverless/app-image.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Generates the application container-image Dockerfile for serverless apps that
+ * exceed the 250 MB zip/layer limit (`packaging: 'image'`). Lambda runs the
+ * image directly (up to 10 GB).
+ *
+ * - Node/Bun: FROM the AWS Lambda Node base image; the bundled handler is copied
+ *   to the task root and the function's `ImageConfig.Command` selects the export.
+ * - PHP: a self-contained multi-stage build — stage 1 compiles + relocates PHP
+ *   (the same recipe as the runtime layer), stage 2 is the `provided.al2023`
+ *   base with /opt (runtime) + /var/task (app) baked in; the bootstrap selects
+ *   the mode from `TSCLOUD_LAMBDA_MODE`.
+ */
+export interface AppImageDockerfileOptions {
+    kind: 'node' | 'bun' | 'php';
+    /** Node runtime tag (e.g. '20') — used for the Lambda Node base image. */
+    nodeMajor?: string;
+    /** PHP version for the runtime build stage (kind: 'php'). @default '8.3' */
+    phpVersion?: string;
+    /** CPU architecture (documented; the build uses --platform at build time). */
+    architecture?: 'x86_64' | 'arm64';
+}
+export declare function generateAppImageDockerfile(options: AppImageDockerfileOptions): string;

package/dist/serverless/app-image.test.d.ts

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

package/dist/serverless/bootstrap.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates the bootstrap entry module that is bundled as the Lambda artifact's
+ * top-level handler file. It imports the user's application entry plus the
+ * runtime adapter, then re-exports the three Lambda handlers (`http`, `queue`,
+ * `cli`) that API Gateway / SQS / EventBridge invoke.
+ */
+export interface BootstrapOptions {
+    /** Import specifier for the user's app entry (absolute path or bare module). */
+    entryImport: string;
+    /** Import specifier for the runtime adapter. @default './adapter' */
+    adapterImport?: string;
+}
+export declare function generateBootstrap(opts: BootstrapOptions): string;

package/dist/serverless/composer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Composes the CloudFormation template for a Vapor-style serverless application:
+ * one code artifact wired into three Lambda functions (http/queue/cli) plus the
+ * surrounding infrastructure (API Gateway v2, SQS + DLQ, EventBridge scheduler,
+ * DynamoDB cache, assets S3 + CloudFront, IAM role, log groups).
+ *
+ * Activation model (v1): functions target `$LATEST`. The deploy orchestrator
+ * swaps code with `UpdateFunctionCode` (fast, atomic per function) and passes the
+ * current artifact via the `ArtifactBucket` / `ArtifactKey` stack parameters so
+ * stack updates never revert the deployed code. Alias-based blue/green is a v2
+ * refinement.
+ */
+import type { CloudConfig, EnvironmentType, ServerlessAppConfig } from '../types';
+import type { CloudFormationTemplate } from '../cloudformation/types';
+export interface ComposeOptions {
+    config: Pick<CloudConfig, 'project'>;
+    environment: EnvironmentType;
+    app: ServerlessAppConfig;
+    /** Lambda handler strings per function (from packaging). */
+    handlers: {
+        http: string;
+        queue: string;
+        cli: string;
+    };
+    /** Custom-runtime layer ARNs (PHP). */
+    runtimeLayers?: string[];
+}
+export interface ComposedTemplate {
+    template: CloudFormationTemplate;
+    /** Deterministic Lambda function names the orchestrator drives directly. */
+    functionNames: {
+        http: string;
+        queue: string;
+        cli: string;
+    };
+    /** SQS queue names created (for the orchestrator + CLI commands). */
+    queueNames: string[];
+    /** Count of resources by CloudFormation type (for deploy summaries). */
+    resourceSummary: Record<string, number>;
+}
+/** Resolve the SQS queue names from the manifest. */
+export declare function resolveQueueNames(app: ServerlessAppConfig, slug: string, env: EnvironmentType): string[];
+export declare function composeServerlessAppTemplate(opts: ComposeOptions): ComposedTemplate;

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

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

package/dist/serverless/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Serverless application pipeline (Laravel-Vapor-equivalent) for Node/Bun apps.
+ * Packaging, the runtime adapter, and the CloudFormation composer.
+ */
+export * from './zip';
+export * from './bootstrap';
+export * from './package';
+export * from './composer';
+export * from './app-image';
+export * from './runtime/adapter';

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

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

package/dist/serverless/package.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Packages a Node/Bun serverless application into a single Lambda deployment
+ * artifact (a ZIP holding one bundled handler file). The same artifact backs all
+ * three functions (http/queue/cli); they differ only by handler export.
+ *
+ * Flow: run build hooks → write a generated bootstrap that wires the user's
+ * entry to the runtime adapter → bundle with `Bun.build` (target node) → ZIP →
+ * content-hash. The hash is the artifact identity used for skip-by-hash uploads,
+ * redeploys, and rollbacks.
+ */
+import type { ServerlessAppConfig } from '../types';
+export interface PackageOptions {
+    /** Project root the entry/build hooks resolve against. @default process.cwd() */
+    projectRoot?: string;
+    /** The serverless app manifest. */
+    app: ServerlessAppConfig;
+    /** Skip running `app.build` hooks (already run by the orchestrator). */
+    skipBuild?: boolean;
+    /** Progress callback. */
+    onStep?: (message: string) => void;
+}
+export interface PackagedArtifact {
+    /** The ZIP bytes ready to upload to S3 / Lambda. */
+    zip: Buffer;
+    /** The raw bundled JS (before zipping) — used for container-image builds. */
+    bundle: Buffer;
+    /** SHA-256 of the ZIP bytes (hex). Stable for identical inputs. */
+    sha256: string;
+    /** Handler file basename inside the artifact (no extension), e.g. `index`. */
+    handlerFile: string;
+    /** Lambda handler strings for each function. */
+    handlers: {
+        http: string;
+        queue: string;
+        cli: string;
+    };
+    /** Size of the bundled JS before zipping. */
+    bundleBytes: number;
+}
+/** Run build hooks locally, failing fast on the first non-zero exit. */
+export declare function runBuildHooks(hooks: string[] | undefined, cwd: string, onStep?: (m: string) => void): void;
+/** SHA-256 hex of arbitrary bytes. */
+export declare function sha256(data: Buffer | Uint8Array | string): string;
+/** S3 key for a deployment artifact, namespaced by project/env and content hash. */
+export declare function artifactKey(slug: string, environment: string, hash: string): string;
+export declare function packageServerlessApp(opts: PackageOptions): Promise<PackagedArtifact>;

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

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

package/dist/serverless/runtime/adapter.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Serverless runtime adapter (Node/Bun).
+ *
+ * This module is **bundled into the Lambda deployment artifact** and runs inside
+ * the AWS Lambda Node.js runtime, so it must rely only on globals available
+ * there: `Request`, `Response`, `Headers`, `URL`, `Buffer`, `atob`/`btoa`.
+ * It contains no AWS SDK calls and no Node-only filesystem access.
+ *
+ * It translates the three event sources of a Vapor-style serverless app into
+ * plain, framework-agnostic callbacks:
+ *   - HTTP  : API Gateway v2 (payload format 2.0) ⇄ WHATWG `Request`/`Response`
+ *   - Queue : SQS records → per-message job handler with partial-batch failures
+ *   - CLI   : `{ command, args }` → command handler (scheduler / migrations)
+ */
+export interface ApiGatewayProxyEventV2 {
+    version: '2.0';
+    rawPath: string;
+    rawQueryString?: string;
+    cookies?: string[];
+    headers?: Record<string, string | undefined>;
+    body?: string;
+    isBase64Encoded?: boolean;
+    requestContext: {
+        domainName?: string;
+        http: {
+            method: string;
+            path: string;
+            protocol?: string;
+            sourceIp?: string;
+            userAgent?: string;
+        };
+    };
+}
+export interface ApiGatewayProxyResultV2 {
+    statusCode: number;
+    headers?: Record<string, string>;
+    cookies?: string[];
+    body?: string;
+    isBase64Encoded?: boolean;
+}
+export interface SqsRecord {
+    messageId: string;
+    receiptHandle?: string;
+    body: string;
+    attributes?: Record<string, string>;
+    messageAttributes?: Record<string, unknown>;
+    eventSourceARN?: string;
+}
+export interface SqsEvent {
+    Records: SqsRecord[];
+}
+export interface SqsBatchResponse {
+    batchItemFailures: Array<{
+        itemIdentifier: string;
+    }>;
+}
+export interface CliEvent {
+    command: string;
+    args?: string[];
+}
+export interface CliResult {
+    statusCode: number;
+    output: string;
+}
+export type FetchHandler = (request: Request) => Response | Promise<Response>;
+export type JobHandler = (payload: unknown, record: SqsRecord) => unknown | Promise<unknown>;
+export type CommandHandler = (event: CliEvent) => CliResult | Promise<CliResult>;
+/** Lambda handler invoked by API Gateway v2. */
+export type LambdaHttpHandler = (event: ApiGatewayProxyEventV2) => Promise<ApiGatewayProxyResultV2>;
+/** Lambda handler invoked by an SQS event source mapping. */
+export type LambdaQueueHandler = (event: SqsEvent) => Promise<SqsBatchResponse>;
+/** Lambda handler invoked by EventBridge / on-demand for CLI commands. */
+export type LambdaCliHandler = (event: CliEvent) => Promise<CliResult>;
+export interface ServerlessApp {
+    fetch?: FetchHandler;
+    queue?: JobHandler;
+    cli?: CommandHandler;
+}
+/**
+ * Normalize whatever the user's entry module exports into a {@link ServerlessApp}.
+ * Accepts a bare fetch function, an object with `fetch`/`queue`/`cli`, or a
+ * Bun.serve-style `{ default: { fetch } }`.
+ */
+export declare function resolveApp(mod: unknown): ServerlessApp;
+export interface HttpAdapterOptions {
+    /**
+     * Read maintenance state from the environment. When `MAINTENANCE_MODE` is
+     * truthy, requests get a 503 unless they carry the bypass secret in the
+     * `x-maintenance-bypass` header or a `tscloud_bypass` cookie.
+     */
+    maintenance?: {
+        enabled: boolean;
+        bypassSecret?: string;
+    };
+}
+/** Translate an API Gateway v2 event into a WHATWG `Request`. */
+export declare function eventToRequest(event: ApiGatewayProxyEventV2): Request;
+/** Serialize a WHATWG `Response` into an API Gateway v2 result. */
+export declare function responseToResult(response: Response): Promise<ApiGatewayProxyResultV2>;
+/**
+ * Wrap a fetch-style handler into a Lambda HTTP handler for API Gateway v2.
+ * Honors maintenance mode (503 + bypass) before invoking the app.
+ */
+export declare function createHttpHandler(handler: FetchHandler | undefined, opts?: HttpAdapterOptions): LambdaHttpHandler;
+/**
+ * Wrap a job handler into a Lambda SQS handler. Each record is processed
+ * individually; failures are reported via `batchItemFailures` so only failed
+ * messages are retried (requires `ReportBatchItemFailures` on the mapping).
+ */
+export declare function createQueueHandler(handler: JobHandler | undefined): LambdaQueueHandler;
+/**
+ * Wrap a command handler into a Lambda CLI handler. Used by the EventBridge
+ * scheduler (`{ command: 'schedule:run' }`) and on-demand invocations
+ * (deploy hooks, migrations, `cloud command`).
+ */
+export declare function createCliHandler(handler: CommandHandler | undefined): LambdaCliHandler;
+/** Convenience: build all three Lambda handlers from a resolved app. */
+export declare function createHandlers(app: ServerlessApp, opts?: HttpAdapterOptions): {
+    http: LambdaHttpHandler;
+    queue: LambdaQueueHandler;
+    cli: LambdaCliHandler;
+};

package/dist/serverless/zip.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Minimal, dependency-free ZIP writer for Lambda deployment artifacts.
+ *
+ * Lambda deployment packages must be ZIP archives. This generalizes the
+ * single-file writer in `ts-cloud/src/aws/lambda.ts` to multiple files so the
+ * same code path serves a bundled Node/Bun handler (one file) and a full
+ * PHP/Laravel application tree (many files). Uses Node's `zlib` only — no
+ * third-party zip dependency, in keeping with the zero-dependency ethos.
+ */
+export interface ZipEntry {
+    /** POSIX path inside the archive (forward slashes). */
+    name: string;
+    /** File contents. */
+    data: Buffer | Uint8Array | string;
+    /** Unix file mode (e.g. 0o755 for an executable `bootstrap`). @default 0o644 */
+    mode?: number;
+    /** Last-modified date; defaults to the Unix epoch for reproducible artifacts. */
+    date?: Date;
+}
+/**
+ * Build a ZIP archive from a set of entries. Files are deflate-compressed.
+ * External attributes encode the Unix mode so executables stay executable on
+ * extraction (required for a custom-runtime `bootstrap`).
+ */
+export declare function createZip(entries: ZipEntry[]): Buffer;

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

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

package/dist/serverless-php/dockerfile.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Generates the Dockerfile that builds the ts-cloud PHP runtime layer for AWS
+ * Lambda (`provided.al2023`). Built against Amazon Linux 2023 so glibc and the
+ * shared libraries match the Lambda execution environment.
+ *
+ * AL2023's default repos can't select an arbitrary PHP minor version, so we use
+ * the Remi repository's SCL-style packages (`php83-php-*`, installed under
+ * `/opt/remi/php83/`), which lets the same recipe build PHP 8.1–8.4. The PHP
+ * binary, php-fpm, extensions, and their shared-library dependencies are then
+ * relocated under `/opt` so the archive works as a Lambda layer.
+ *
+ * Build it in CI (Docker required) — see {@link buildPhpRuntimeLayerZip}. The
+ * resulting /opt tree is published as a Lambda layer.
+ */
+/**
+ * Laravel + serverless extension suffixes (appended to the `php{XY}-php-` Remi
+ * SCL prefix). `process` provides pcntl/posix; `pecl-redis6` the redis driver.
+ */
+export declare const PHP_LAYER_EXTENSIONS: string[];
+/** Full Remi SCL package names for a given PHP version (e.g. '8.3' → php83-php-*). */
+export declare function phpLayerPackages(phpVersion: string): string[];
+export interface PhpDockerfileOptions {
+    /** PHP version: 8.1 | 8.2 | 8.3 | 8.4. @default '8.3' */
+    phpVersion?: string;
+}
+/**
+ * The `FROM amazonlinux:2023 … /opt` build stage that compiles + relocates PHP.
+ * Shared by the standalone layer build and the multi-stage app-image build.
+ * Pass `asName` to emit `FROM amazonlinux:2023 AS <name>` for multi-stage use.
+ */
+export declare function phpLayerBuildStage(phpVersion: string, asName?: string): string;
+/**
+ * Standalone Dockerfile that builds the PHP runtime layer payload at /opt.
+ * Used by {@link buildPhpRuntimeLayerZip}.
+ */
+export declare function generatePhpLayerDockerfile(options?: PhpDockerfileOptions): string;

package/dist/serverless-php/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * PHP/Laravel-on-Lambda runtime (true Laravel-Vapor clone).
+ * Custom runtime layer assets, FPM bridge config, Dockerfile + layer builder,
+ * and Laravel serverless environment defaults.
+ */
+export * from './php-fpm-conf';
+export * from './runtime-assets';
+export * from './dockerfile';
+export * from './layer-build';
+export * from './package-php';

package/dist/serverless-php/layer-build.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Builds the ts-cloud PHP runtime layer ZIP.
+ *
+ * Runs the generated Dockerfile to produce a /opt tree (PHP + php-fpm +
+ * extensions for AL2023), extracts it, injects the runtime assets
+ * (bootstrap/runtime loops/fpm config), and packages everything as a Lambda
+ * layer ZIP. Publishing the ZIP as a layer version is done by the CLI using the
+ * ts-cloud Lambda client; this module only produces the artifact.
+ *
+ * Requires Docker. Intended to run in CI to publish a versioned, ts-cloud-owned
+ * layer that user deploys reference (no per-deploy compilation).
+ */
+import { type PhpDockerfileOptions } from './dockerfile';
+export interface BuildPhpLayerOptions extends PhpDockerfileOptions {
+    /** Target architecture. @default 'x86_64' */
+    architecture?: 'x86_64' | 'arm64';
+    /** Docker platform override (defaults from architecture). */
+    platform?: string;
+    /** Progress callback. */
+    onStep?: (message: string) => void;
+}
+export interface PhpLayerArtifact {
+    /** The Lambda layer ZIP bytes. */
+    zip: Buffer;
+    /** Compatible architecture. */
+    architecture: 'x86_64' | 'arm64';
+    /** Number of files in the layer. */
+    fileCount: number;
+}
+/**
+ * Build the PHP runtime layer ZIP via Docker. Throws if Docker is unavailable.
+ */
+export declare function buildPhpRuntimeLayerZip(options?: BuildPhpLayerOptions): PhpLayerArtifact;

package/dist/serverless-php/package-php.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Packages a Laravel/PHP application into a Lambda deployment artifact.
+ *
+ * Unlike the Node/Bun path (which bundles a single JS file), a PHP app ships its
+ * whole source tree (vendor/ + app/ + public/ + bootstrap/ …). The PHP binary,
+ * php-fpm, and the runtime loop come from the PHP runtime layer, not the artifact.
+ * Build hooks (composer install + artisan caches) run before packaging because
+ * the Lambda filesystem is read-only at runtime.
+ */
+import type { ServerlessAppConfig } from '../types';
+import { type ZipEntry } from '../serverless/zip';
+/** Paths excluded from the PHP deployment artifact by default. */
+export declare const PHP_DEFAULT_EXCLUDES: string[];
+export interface PackagePhpOptions {
+    projectRoot?: string;
+    app: ServerlessAppConfig;
+    skipBuild?: boolean;
+    /** Extra path prefixes (relative to root) to exclude. */
+    exclude?: string[];
+    onStep?: (message: string) => void;
+}
+export interface PackagedPhpArtifact {
+    zip: Buffer;
+    sha256: string;
+    handlers: {
+        http: string;
+        queue: string;
+        cli: string;
+    };
+    fileCount: number;
+}
+/**
+ * Run the PHP build hooks (composer install + artisan caches) for a project.
+ * Defaults to the Laravel serverless caching steps when none are configured.
+ */
+export declare function runPhpBuildHooks(opts: PackagePhpOptions): void;
+/**
+ * Collect the PHP application file tree (respecting excludes) as zip entries.
+ * Shared by {@link packagePhpApp} (zips) and the container-image staging (writes
+ * the entries to a build context).
+ */
+export declare function collectPhpAppEntries(projectRoot: string, exclude?: string[]): ZipEntry[];
+export declare function packagePhpApp(opts: PackagePhpOptions): PackagedPhpArtifact;

package/dist/serverless-php/php-fpm-conf.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Generates the php-fpm.conf used by the ts-cloud PHP Lambda runtime.
+ *
+ * A Lambda container serves exactly one request at a time, so FPM is configured
+ * with a single static worker listening on a unix socket in /tmp (the only
+ * writable location). Output goes to stderr → CloudWatch.
+ */
+export interface PhpFpmConfigOptions {
+    /** Unix socket path FPM listens on. @default '/tmp/.tscloud-fpm.sock' */
+    socketPath?: string;
+    /** Workers per container. Lambda is single-request, so 1 is correct. @default 1 */
+    maxChildren?: number;
+    /** php-fpm error log path. @default '/tmp/storage/logs/php-fpm.log' */
+    errorLog?: string;
+}
+export declare function generatePhpFpmConfig(options?: PhpFpmConfigOptions): string;