functualize-lambda 0.1.0__tar.gz

functualize_lambda-0.1.0/.gitignore

@@ -0,0 +1,101 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+*.egg
+dist/
+build/
+*.whl
+
+# Agents
+.spec/archive/
+.spec/features/
+.spec/scrutiny-reports/
+.spec/.agentic-coding
+.spec/STATE.md
+.spec/PROJECT.md
+.spec/REQUIREMENTS.md
+.spec/ROADMAP.md
+.opencode/
+
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Testing
+.coverage
+.pytest_cache/
+htmlcov/
+.hypothesis/
+snapshot_report.html
+_*_result*.txt
+_debug.txt
+_tui_debug.txt
+_tui_eval_debug.txt
+
+# IDE
+.idea/
+*.swp
+*.swo
+*~
+*.code-workspace
+
+# Coding-agent tooling state (guards — these dirs are not part of the repo)
+.kiro/
+.moai/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment / secrets
+.env
+.env.*
+!.env.example
+
+# Agent scratch space (test output, temp scripts)
+tmp/
+
+# Local-only files (not for the repo)
+*.local.md
+*.local.*
+
+# Personal notes
+HUMAN_NOTE.md
+
+# Distribution
+dist/
+
+# Documentation site build output
+site/
+
+# uv
+.python-version
+.functualize/cache.json
+.functualize_cache.json
+.todos/
+.sidecar/
+.sidecar-agent
+.sidecar-task
+.sidecar-pr
+.sidecar-start.sh
+.sidecar-base
+.td-root
+.functualize/
+.import_linter_cache/
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+
+# OmO / OpenCode agent run-continuation scratch state
+.omo/
+.mcp.json
+.agentsroom/handoff-transcript-*.txt
+.agentsroom/handoff-summary-*.md
+
+# Internal pre-release audit reports (contain session IDs / local infra notes)
+.release/

functualize_lambda-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: functualize-lambda
+Version: 0.1.0
+Summary: AWS Lambda adapter plugin for functualize - supports fat and thin Lambda deployment patterns
+Author-email: Mohammad Hakim Adiprasetya <viltohmyst@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: functualize<1.0.0,>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# functualize-lambda
+
+> **Status: Published** — Independently installable from PyPI.
+
+AWS Lambda adapter plugin for [functualize](https://github.com/raicing-ai/functualize).
+
+Supports two deployment patterns:
+
+1. **Fat Lambda** — Single Lambda function with internal routing via `event["job"]`
+2. **Thin Lambda** — One Lambda per job via `make_handler(job_name)`
+
+## Installation
+
+```bash
+pip install functualize-lambda
+```
+
+## Usage
+
+### Fat Lambda (internal routing)
+
+```python
+from functualize.app import FunctualizeApp, JobSources
+from functualize_lambda import LambdaAdapter
+
+app = FunctualizeApp("my-app", job_sources=JobSources(functions=[deploy, rollback]))
+adapter = LambdaAdapter()
+adapter(app)
+
+def handler(event, context):
+    return adapter.run(event, context)
+```
+
+Events should have the shape: `{"job": "job_name", "kwargs": {"key": "value"}}`
+
+### Thin Lambda (per-job handler)
+
+```python
+from functualize.app import FunctualizeApp, JobSources
+from functualize_lambda import LambdaAdapter
+
+app = FunctualizeApp("my-app", job_sources=JobSources(functions=[deploy]))
+adapter = LambdaAdapter()
+adapter(app)
+
+handler = adapter.make_handler("deploy")
+```

functualize_lambda-0.1.0/README.md

@@ -0,0 +1,47 @@
+# functualize-lambda
+
+> **Status: Published** — Independently installable from PyPI.
+
+AWS Lambda adapter plugin for [functualize](https://github.com/raicing-ai/functualize).
+
+Supports two deployment patterns:
+
+1. **Fat Lambda** — Single Lambda function with internal routing via `event["job"]`
+2. **Thin Lambda** — One Lambda per job via `make_handler(job_name)`
+
+## Installation
+
+```bash
+pip install functualize-lambda
+```
+
+## Usage
+
+### Fat Lambda (internal routing)
+
+```python
+from functualize.app import FunctualizeApp, JobSources
+from functualize_lambda import LambdaAdapter
+
+app = FunctualizeApp("my-app", job_sources=JobSources(functions=[deploy, rollback]))
+adapter = LambdaAdapter()
+adapter(app)
+
+def handler(event, context):
+    return adapter.run(event, context)
+```
+
+Events should have the shape: `{"job": "job_name", "kwargs": {"key": "value"}}`
+
+### Thin Lambda (per-job handler)
+
+```python
+from functualize.app import FunctualizeApp, JobSources
+from functualize_lambda import LambdaAdapter
+
+app = FunctualizeApp("my-app", job_sources=JobSources(functions=[deploy]))
+adapter = LambdaAdapter()
+adapter(app)
+
+handler = adapter.make_handler("deploy")
+```

functualize_lambda-0.1.0/examples/README.md

@@ -0,0 +1,18 @@
+# functualize-lambda Examples
+
+The AWS Lambda delivery adapter: run jobs serverless.
+
+| Directory | Demonstrates |
+|-----------|--------------|
+| [`lambda_handler/`](lambda_handler/) | "Fat Lambda" (one function routing all jobs) and "thin Lambda" (one function per job) deployment patterns |
+
+```bash
+cd plugins/functualize-lambda/examples/lambda_handler
+uv sync
+```
+
+Tests:
+
+```bash
+uv run pytest plugins/functualize-lambda/examples/ -v
+```

functualize_lambda-0.1.0/examples/lambda_handler/README.md

@@ -0,0 +1,60 @@
+# Lambda Handler — Project Example
+
+A functualize project deployed as AWS Lambda functions using the `functualize-lambda` adapter. Demonstrates both "fat Lambda" (single function with routing) and "thin Lambda" (one function per job) patterns.
+
+## Setup
+
+```bash
+cd plugins/functualize-lambda/examples/lambda_handler
+uv sync
+```
+
+## Deployment Patterns
+
+### Fat Lambda (Internal Routing)
+
+Single Lambda function that routes to different jobs based on the event payload:
+
+```python
+# handler.py
+from lambda_service.app import fat_handler
+
+def handler(event, context):
+    return fat_handler(event, context)
+```
+
+Event format: `{"job": "process_order", "kwargs": {"order_id": "ORD-123"}}`
+
+### Thin Lambda (Per-Job)
+
+One Lambda function per job — simpler IAM, clearer monitoring:
+
+```python
+# handlers/process_order.py
+from lambda_service.app import process_order_handler
+
+handler = process_order_handler
+```
+
+## Testing Locally
+
+```bash
+# Test job functions directly
+uv run pytest tests/ -v
+
+# Simulate a Lambda invocation
+uv run python -c "
+from lambda_service.app import fat_handler
+result = fat_handler({'job': 'process_order', 'kwargs': {'order_id': 'ORD-001', 'amount': 99.99}}, None)
+print(result)
+"
+```
+
+## What This Demonstrates
+
+- `FunctualizeApp` with `JobSources(functions=[...])` for explicit registration
+- `LambdaAdapter` for AWS Lambda delivery
+- Fat Lambda pattern with event routing
+- Thin Lambda pattern with `make_handler()`
+- `twelve_factor()` config preset (env vars only — no files in Lambda)
+- Same jobs testable locally without AWS

functualize_lambda-0.1.0/examples/lambda_handler/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "lambda-service"
+version = "0.1.0"
+description = "Example: Functualize jobs deployed as AWS Lambda functions"
+requires-python = ">=3.11"
+dependencies = [
+    "functualize",
+    "functualize-lambda",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lambda_service"]
+
+[tool.uv.sources]
+functualize = { path = "../../../..", editable = true }
+functualize-lambda = { path = "../..", editable = true }

functualize_lambda-0.1.0/examples/lambda_handler/src/lambda_service/__init__.py

@@ -0,0 +1 @@
+"""Lambda service example — functualize jobs deployed to AWS Lambda."""

functualize_lambda-0.1.0/examples/lambda_handler/src/lambda_service/app.py

@@ -0,0 +1,44 @@
+"""Lambda application wiring — configures FunctualizeApp with Lambda adapter.
+
+Demonstrates two deployment patterns:
+1. Fat Lambda — single handler routing via event["job"]
+2. Thin Lambda — one handler per job via make_handler()
+"""
+
+from functualize_lambda import LambdaAdapter
+
+from functualize.app import FunctualizeApp, JobSources, twelve_factor
+from lambda_service.jobs import process_order, send_notification
+
+# Create the app with explicit function registration (no directory scanning).
+# This minimizes cold start time in Lambda — no filesystem I/O at boot.
+app = FunctualizeApp(
+    name="lambda-service",
+    job_sources=JobSources(functions=[process_order, send_notification]),
+    config_sources=twelve_factor(),  # Env vars only — no config files in Lambda
+)
+
+# Create the Lambda adapter
+adapter = LambdaAdapter()
+adapter(app)
+
+
+# ---------------------------------------------------------------------------
+# Fat Lambda handler — routes based on event["job"]
+# ---------------------------------------------------------------------------
+
+
+def fat_handler(event: dict, context) -> dict:
+    """Single Lambda entry point with internal job routing.
+
+    Event format: {"job": "process_order", "kwargs": {"order_id": "ORD-123"}}
+    """
+    return adapter.run(event, context)
+
+
+# ---------------------------------------------------------------------------
+# Thin Lambda handlers — one per job
+# ---------------------------------------------------------------------------
+
+process_order_handler = adapter.make_handler("process_order")
+send_notification_handler = adapter.make_handler("send_notification")

functualize_lambda-0.1.0/examples/lambda_handler/src/lambda_service/jobs.py

@@ -0,0 +1,82 @@
+"""Job definitions for the Lambda service.
+
+These jobs are registered explicitly via JobSources(functions=[...])
+rather than directory scanning — common in Lambda where cold start
+time matters and we want minimal import overhead.
+"""
+
+from pydantic import BaseModel, Field
+
+from functualize.job.context import RunContext
+from functualize.job.decorators import job
+
+# ---------------------------------------------------------------------------
+# Job 1: Process Order
+# ---------------------------------------------------------------------------
+
+
+class ProcessOrderConfig(BaseModel):
+    """Configuration for order processing."""
+
+    order_id: str = Field(description="Order identifier")
+    amount: float = Field(ge=0, description="Order amount in USD")
+    priority: bool = Field(default=False, description="Priority processing flag")
+
+
+@job(
+    extra_description="Process an incoming order and validate payment",
+    category="orders",
+    tags=["order", "payment"],
+    visibility="external",
+)
+def process_order(config: ProcessOrderConfig, rc: RunContext) -> dict:
+    """Process an order — validate, charge, and confirm.
+
+    In production this would integrate with payment providers and
+    inventory systems. Here we simulate the happy path.
+    """
+    rc.log(f"Processing order {config.order_id} (${config.amount:.2f})")
+
+    if config.priority:
+        rc.log("Priority processing enabled")
+
+    return {
+        "order_id": config.order_id,
+        "status": "processed",
+        "amount": config.amount,
+        "priority": config.priority,
+        "confirmation_code": f"CONF-{config.order_id[-4:]}",
+    }
+
+
+# ---------------------------------------------------------------------------
+# Job 2: Send Notification
+# ---------------------------------------------------------------------------
+
+
+class NotificationConfig(BaseModel):
+    """Configuration for sending notifications."""
+
+    recipient: str = Field(description="Email or user ID")
+    message: str = Field(description="Notification message body")
+    channel: str = Field(
+        default="email", description="Delivery channel: email, sms, push"
+    )
+
+
+@job(
+    extra_description="Send a notification to a user via the specified channel",
+    category="messaging",
+    tags=["notification", "messaging"],
+    visibility="external",
+)
+def send_notification(config: NotificationConfig, rc: RunContext) -> dict:
+    """Send a notification through the configured channel."""
+    rc.log(f"Sending {config.channel} to {config.recipient}")
+
+    return {
+        "recipient": config.recipient,
+        "channel": config.channel,
+        "status": "sent",
+        "message_preview": config.message[:50],
+    }

functualize_lambda-0.1.0/examples/lambda_handler/tests/test_lambda_jobs.py

@@ -0,0 +1,84 @@
+"""Tests for Lambda service jobs — prove they work without AWS."""
+
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from lambda_service.jobs import (
+    NotificationConfig,
+    ProcessOrderConfig,
+    process_order,
+    send_notification,
+)
+
+
+def _make_rc():
+    """Create a minimal mock RunContext for testing."""
+    rc = MagicMock()
+    rc.log = MagicMock()
+    return rc
+
+
+class TestProcessOrder:
+    """Tests for the process_order job."""
+
+    def test_processes_order_successfully(self):
+        rc = _make_rc()
+        config = ProcessOrderConfig(order_id="ORD-001", amount=49.99)
+        result = process_order(config, rc)
+
+        assert result["order_id"] == "ORD-001"
+        assert result["status"] == "processed"
+        assert result["amount"] == 49.99
+        assert result["confirmation_code"] == "CONF--001"
+
+    def test_priority_processing(self):
+        rc = _make_rc()
+        config = ProcessOrderConfig(order_id="ORD-VIP", amount=199.99, priority=True)
+        result = process_order(config, rc)
+
+        assert result["priority"] is True
+        log_calls = [str(call) for call in rc.log.call_args_list]
+        assert any("Priority" in call for call in log_calls)
+
+    def test_zero_amount_order(self):
+        rc = _make_rc()
+        config = ProcessOrderConfig(order_id="ORD-FREE", amount=0.0)
+        result = process_order(config, rc)
+
+        assert result["amount"] == 0.0
+        assert result["status"] == "processed"
+
+
+class TestSendNotification:
+    """Tests for the send_notification job."""
+
+    def test_sends_email_notification(self):
+        rc = _make_rc()
+        config = NotificationConfig(
+            recipient="user@example.com", message="Your order is ready!"
+        )
+        result = send_notification(config, rc)
+
+        assert result["recipient"] == "user@example.com"
+        assert result["channel"] == "email"
+        assert result["status"] == "sent"
+
+    def test_sends_sms_notification(self):
+        rc = _make_rc()
+        config = NotificationConfig(
+            recipient="+1234567890", message="Delivery arriving", channel="sms"
+        )
+        result = send_notification(config, rc)
+
+        assert result["channel"] == "sms"
+
+    def test_message_preview_truncated(self):
+        rc = _make_rc()
+        long_message = "A" * 100
+        config = NotificationConfig(recipient="user@test.com", message=long_message)
+        result = send_notification(config, rc)
+
+        assert len(result["message_preview"]) == 50

functualize_lambda-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "functualize-lambda"
+version = "0.1.0"
+description = "AWS Lambda adapter plugin for functualize - supports fat and thin Lambda deployment patterns"
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Mohammad Hakim Adiprasetya", email = "viltohmyst@gmail.com" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "functualize>=0.1.0,<1.0.0",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+
+[project.entry-points."functualize.plugins"]
+lambda = "functualize_lambda:LambdaAdapter"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-cov>=4.1.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv.sources]
+functualize = { workspace = true }
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/functualize_lambda"]

functualize_lambda-0.1.0/src/functualize_lambda/__init__.py

@@ -0,0 +1,171 @@
+"""Functualize Lambda Adapter Plugin — AWS Lambda delivery for FunctualizeApp.
+
+Implements the AdapterPlugin Protocol with adapter_type="lambda".
+Supports two deployment patterns:
+
+1. Fat Lambda (internal routing):
+   - Single Lambda function handling multiple jobs
+   - Event contains {"job": "job_name", "kwargs": {...}}
+   - Adapter routes to the correct job via app.execute()
+
+2. Thin Lambda (per-job handler):
+   - One Lambda function per job, routing handled by infrastructure
+   - Use make_handler(job_name) to create a bound handler
+
+Both patterns work with the static wiring fast path for <5ms cold start
+when using JobSources(functions=[...]) with fully-explicit config.
+
+Usage (fat Lambda):
+    app = FunctualizeApp("my-app", job_sources=JobSources(functions=[deploy, rollback]))
+    adapter = LambdaAdapter()
+    adapter(app)
+
+    def handler(event, context):
+        return adapter.run(event, context)
+
+Usage (thin Lambda):
+    app = FunctualizeApp("my-app", job_sources=JobSources(functions=[deploy]))
+    adapter = LambdaAdapter()
+    adapter(app)
+
+    handler = adapter.make_handler("deploy")
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from functualize.app.core import FunctualizeApp
+
+
+class LambdaAdapter:
+    """AWS Lambda delivery adapter.
+
+    Satisfies the AdapterPlugin Protocol. Supports fat-Lambda (internal
+    routing via event["job"]) and thin-Lambda (per-job handler via
+    make_handler()) deployment patterns.
+
+    PluginMetadata attributes:
+        name: "functualize-lambda"
+        version: "1.0.0"
+        description: "AWS Lambda adapter supporting fat and thin Lambda patterns"
+    """
+
+    name: str = "functualize-lambda"
+    version: str = "1.0.0"
+    description: str = "AWS Lambda adapter supporting fat and thin Lambda patterns"
+    adapter_type: str = "lambda"
+
+    def __init__(self) -> None:
+        self._app: FunctualizeApp | None = None
+
+    def __call__(self, app: FunctualizeApp) -> None:
+        """Setup phase — store app reference.
+
+        Args:
+            app: The FunctualizeApp kernel instance.
+        """
+        self._app = app
+
+    def run(self, *args: Any, **kwargs: Any) -> Any:
+        """Fat Lambda entrypoint — route event to the correct job.
+
+        Parses the event to determine which job to execute and with
+        what arguments, then delegates to the kernel's execute method.
+
+        Args:
+            *args: Expected to be (event, context) where event is a dict
+                containing "job" (required) and "kwargs" (optional).
+
+        Returns:
+            Dict with "statusCode" (200 or 500) and "body" (result or
+            error message).
+
+        Raises:
+            RuntimeError: If run() is called before __call__(app).
+        """
+        if self._app is None:
+            raise RuntimeError("LambdaAdapter.run() called before __call__(app)")
+
+        # Extract event and context from positional args
+        event: dict[str, Any] = args[0] if args else kwargs.get("event", {})
+        # context is available but not used by the adapter itself
+        # _context = args[1] if len(args) > 1 else kwargs.get("context")
+
+        return self._handle_event(event)
+
+    def make_handler(self, job_name: str) -> Callable[..., Any]:
+        """Create a thin-Lambda handler bound to a specific job.
+
+        Returns a callable with the standard Lambda signature
+        (event, context) that always executes the specified job.
+        Event kwargs can still be provided via event.get("kwargs", {}).
+
+        Args:
+            job_name: The name of the job this handler will execute.
+
+        Returns:
+            A callable(event, context) -> dict suitable as a Lambda handler.
+
+        Raises:
+            RuntimeError: If make_handler() is called before __call__(app).
+        """
+        if self._app is None:
+            raise RuntimeError(
+                "LambdaAdapter.make_handler() called before __call__(app)"
+            )
+
+        app = self._app
+
+        def handler(event: dict[str, Any], context: Any) -> dict[str, Any]:
+            """Thin Lambda handler for job '{job_name}'."""
+            job_kwargs = event.get("kwargs", {})
+            try:
+                result = app.execute(job_name, **job_kwargs)
+                return {"statusCode": 200, "body": result.return_value}
+            except Exception as exc:
+                return {"statusCode": 500, "body": str(exc)}
+
+        # Set a useful name for debugging/logging
+        handler.__name__ = f"lambda_handler_{job_name}"
+        handler.__qualname__ = (
+            f"LambdaAdapter.make_handler.<locals>.handler[{job_name}]"
+        )
+
+        return handler
+
+    def shutdown(self) -> None:
+        """No-op shutdown. Lambda functions are stateless."""
+        pass
+
+    def _handle_event(self, event: dict[str, Any]) -> dict[str, Any]:
+        """Internal: parse event and execute the job.
+
+        Args:
+            event: Lambda event dict with "job" and optional "kwargs".
+
+        Returns:
+            Dict with "statusCode" and "body".
+        """
+        assert self._app is not None
+
+        try:
+            job_name = event["job"]
+        except (KeyError, TypeError) as exc:
+            return {
+                "statusCode": 400,
+                "body": f"Missing required field 'job' in event: {exc}",
+            }
+
+        job_kwargs = event.get("kwargs", {})
+
+        try:
+            result = self._app.execute(job_name, **job_kwargs)
+            return {"statusCode": 200, "body": result.return_value}
+        except Exception as exc:
+            return {"statusCode": 500, "body": str(exc)}
+
+
+__all__ = ["LambdaAdapter"]

functualize_lambda-0.1.0/tests/conftest.py

@@ -0,0 +1,44 @@
+"""Shared fixtures for functualize-lambda plugin tests."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import pytest
+
+
+@dataclass
+class FakeJobResult:
+    status: str = "success"
+    return_value: Any = None
+    duration_ms: float = 10.0
+
+
+class FakeApp:
+    """Minimal FunctualizeApp fake for Lambda adapter tests."""
+
+    def __init__(
+        self,
+        execute_results: dict[str, FakeJobResult] | None = None,
+        execute_error: Exception | None = None,
+    ):
+        self._execute_results = execute_results or {}
+        self._execute_error = execute_error
+
+    def execute(self, job_name: str, **kwargs: Any) -> FakeJobResult:
+        if self._execute_error:
+            raise self._execute_error
+        if job_name in self._execute_results:
+            return self._execute_results[job_name]
+        return FakeJobResult(return_value=f"executed {job_name}")
+
+
+@pytest.fixture
+def fake_app() -> FakeApp:
+    return FakeApp()
+
+
+@pytest.fixture
+def failing_app() -> FakeApp:
+    return FakeApp(execute_error=RuntimeError("deploy failed"))

functualize_lambda-0.1.0/tests/test_plugin.py

@@ -0,0 +1,98 @@
+"""Unit tests for functualize-lambda plugin.
+
+Tests the Lambda adapter's fat-lambda routing, thin-lambda handler creation,
+and error handling.
+"""
+
+from __future__ import annotations
+
+import pytest
+from functualize_lambda import LambdaAdapter
+
+
+class TestFatLambda:
+    """Tests for fat-Lambda (internal routing via event['job'])."""
+
+    def test_routes_to_correct_job(self, fake_app):
+        adapter = LambdaAdapter()
+        adapter(fake_app)
+        result = adapter.run({"job": "deploy", "kwargs": {"env": "prod"}}, None)
+        assert result["statusCode"] == 200
+        assert result["body"] == "executed deploy"
+
+    def test_missing_job_field_returns_400(self, fake_app):
+        adapter = LambdaAdapter()
+        adapter(fake_app)
+        result = adapter.run({}, None)
+        assert result["statusCode"] == 400
+        assert "Missing required field" in result["body"]
+
+    def test_execution_error_returns_500(self, failing_app):
+        adapter = LambdaAdapter()
+        adapter(failing_app)
+        result = adapter.run({"job": "deploy"}, None)
+        assert result["statusCode"] == 500
+        assert "deploy failed" in result["body"]
+
+    def test_run_before_setup_raises(self):
+        adapter = LambdaAdapter()
+        with pytest.raises(RuntimeError, match="called before __call__"):
+            adapter.run({"job": "test"}, None)
+
+    def test_kwargs_default_to_empty(self, fake_app):
+        adapter = LambdaAdapter()
+        adapter(fake_app)
+        result = adapter.run({"job": "deploy"}, None)
+        assert result["statusCode"] == 200
+
+
+class TestThinLambda:
+    """Tests for thin-Lambda (per-job handlers via make_handler)."""
+
+    def test_make_handler_creates_callable(self, fake_app):
+        adapter = LambdaAdapter()
+        adapter(fake_app)
+        handler = adapter.make_handler("deploy")
+        assert callable(handler)
+
+    def test_handler_executes_bound_job(self, fake_app):
+        adapter = LambdaAdapter()
+        adapter(fake_app)
+        handler = adapter.make_handler("deploy")
+        result = handler({"kwargs": {"env": "staging"}}, None)
+        assert result["statusCode"] == 200
+        assert result["body"] == "executed deploy"
+
+    def test_handler_error_returns_500(self, failing_app):
+        adapter = LambdaAdapter()
+        adapter(failing_app)
+        handler = adapter.make_handler("deploy")
+        result = handler({}, None)
+        assert result["statusCode"] == 500
+        assert "deploy failed" in result["body"]
+
+    def test_make_handler_before_setup_raises(self):
+        adapter = LambdaAdapter()
+        with pytest.raises(RuntimeError, match="called before __call__"):
+            adapter.make_handler("deploy")
+
+    def test_handler_has_descriptive_name(self, fake_app):
+        adapter = LambdaAdapter()
+        adapter(fake_app)
+        handler = adapter.make_handler("deploy")
+        assert "deploy" in handler.__name__
+
+
+class TestAdapterMetadata:
+    """Tests for adapter metadata attributes."""
+
+    def test_has_required_attributes(self):
+        adapter = LambdaAdapter()
+        assert adapter.name == "functualize-lambda"
+        assert adapter.adapter_type == "lambda"
+        assert adapter.version
+
+    def test_shutdown_is_noop(self, fake_app):
+        adapter = LambdaAdapter()
+        adapter(fake_app)
+        adapter.shutdown()  # Should not raise