lumera 0.40.2.dev20260830__tar.gz → 0.40.3.dev2026090401__tar.gz

{lumera-0.40.2.dev20260830 → lumera-0.40.3.dev2026090401}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumera
-Version: 0.40.2.dev20260830
+Version: 0.40.3.dev2026090401
 Summary: SDK for building on Lumera platform
 Requires-Python: >=3.11
 Requires-Dist: requests

{lumera-0.40.2.dev20260830 → lumera-0.40.3.dev2026090401}/lumera/releases/_api_child.py

@@ -10,14 +10,28 @@ import sys
 import tempfile
 import threading
 import time
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 from urllib.parse import urlparse
 from urllib.request import Request, urlopen
 
+from ._durable_event import execute_durable_event
 from ._projection import ASGIApp, ASGIReceive, ASGISend, create_runtime_app
 
 MAX_RELEASE_BYTES = 250 * 1024 * 1024
+MAX_EVENT_INPUT = 1_000_000
+WARMED_DURABLE_EVENTS_FEATURE = "durable_function_events_v1"
+
+
+@dataclass(frozen=True)
+class _LoadedRelease:
+    app: ASGIApp
+    temporary_root: Path
+
+    @property
+    def root(self) -> Path:
+        return self.temporary_root / "release"
 
 
 class LazyReleaseApp:
@@ -25,7 +39,7 @@ class LazyReleaseApp:
 
     def __init__(self) -> None:
         self._lock = threading.Lock()
-        self._app: ASGIApp | None = None
+        self._release: _LoadedRelease | None = None
         self._startup_lock: asyncio.Lock | None = None
         self._started = False
         self._lifespan_input: asyncio.Queue[dict[str, object]] | None = None
@@ -46,28 +60,77 @@ class LazyReleaseApp:
             await _json_response(
                 send,
                 200,
-                {"status": "healthy", "release_loaded": self._app is not None},
+                {"status": "healthy", "release_loaded": self._release is not None},
             )
             return
-        app = await self._ready_app()
+        method = str(scope.get("method", "GET")).upper()
+        if scope.get("type") == "http" and method == "POST" and path == "/__lumera/events":
+            await self._serve_durable_event(receive, send)
+            return
+        app = (await self._ready_release()).app
         if scope.get("type") == "http" and path == "/__lumera/warm":
             scope = {**scope, "path": "/__lumera/health", "raw_path": b"/__lumera/health"}
         await app(scope, receive, send)
 
-    async def _ready_app(self) -> ASGIApp:
-        if self._started and self._app is not None:
-            return self._app
+    async def _ready_release(self) -> _LoadedRelease:
+        if self._started and self._release is not None:
+            return self._release
         if self._startup_lock is None:
             self._startup_lock = asyncio.Lock()
         async with self._startup_lock:
-            if self._started and self._app is not None:
-                return self._app
-            app = self._app
-            if app is None:
-                app = await asyncio.to_thread(self._load)
-            await self._start_project_lifespan(app)
+            if self._started and self._release is not None:
+                return self._release
+            release = self._release
+            if release is None:
+                release = await asyncio.to_thread(self._load)
+            await self._start_project_lifespan(release.app)
             self._started = True
-            return app
+            return release
+
+    async def _serve_durable_event(self, receive: ASGIReceive, send: ASGISend) -> None:
+        body = bytearray()
+        more = True
+        while more:
+            event = await receive()
+            if event.get("type") == "http.disconnect":
+                return
+            if event.get("type") != "http.request":
+                continue
+            body.extend(event.get("body", b""))
+            if len(body) > MAX_EVENT_INPUT:
+                await _json_response(send, 413, {"error": "event too large"})
+                return
+            more = bool(event.get("more_body"))
+
+        async def ready_release() -> tuple[Path, Path]:
+            release = await self._ready_release()
+            return release.root, release.temporary_root
+
+        try:
+            message = json.loads(body or b"{}")
+            if not isinstance(message, dict):
+                raise ValueError("event must be an object")
+            status, response = await execute_durable_event(
+                message,
+                ready_release=ready_release,
+            )
+        except ValueError as exc:
+            status, response = 400, {"error": str(exc)}
+        except BaseException as exc:
+            correlation_id = f"fn_{os.urandom(16).hex()}"
+            _log_event(
+                "functions.app.dispatch_failed",
+                error_type=type(exc).__name__,
+                correlation_id=correlation_id,
+            )
+            status, response = (
+                500,
+                {
+                    "error": "durable Function dispatch failed",
+                    "correlation_id": correlation_id,
+                },
+            )
+        await _json_response(send, status, response)
 
     async def _start_project_lifespan(self, app: ASGIApp) -> None:
         input_queue: asyncio.Queue[dict[str, object]] = asyncio.Queue()
@@ -127,12 +190,12 @@ class LazyReleaseApp:
                 await self._lifespan_task
         await send({"type": "lifespan.shutdown.complete"})
 
-    def _load(self) -> ASGIApp:
+    def _load(self) -> _LoadedRelease:
         with self._lock:
-            if self._app is not None:
-                return self._app
-            self._app = _load_release_app()
-            return self._app
+            if self._release is not None:
+                return self._release
+            self._release = _load_release_app()
+            return self._release
 
 
 def _fresh_release_url(expected_digest: str) -> str:
@@ -182,7 +245,7 @@ def _download_release(url: str, destination: Path) -> int:
     return total
 
 
-def _load_release_app() -> ASGIApp:
+def _load_release_app() -> _LoadedRelease:
     started = time.perf_counter()
     digest = os.environ.get("LUMERA_RELEASE_DIGEST", "").strip()
     if len(digest) != 64 or any(character not in "0123456789abcdef" for character in digest):
@@ -239,11 +302,7 @@ def _load_release_app() -> ASGIApp:
     app = create_runtime_app(
         project_app,  # type: ignore[arg-type]
         manifest,
-        health={
-            "release_digest": digest,
-            "runtime_abi": expected_abi,
-            "image_digest": os.environ.get("FUNCTIONS_RUNTIME_IMAGE_DIGEST", ""),
-        },
+        health=_runtime_health(digest, expected_abi),
     )
     imported_ms = _elapsed_ms(import_started)
     _log_event(
@@ -256,7 +315,16 @@ def _load_release_app() -> ASGIApp:
         imported_ms=round(imported_ms, 1),
         total_ms=round(_elapsed_ms(started), 1),
     )
-    return app
+    return _LoadedRelease(app=app, temporary_root=temporary_root)
+
+
+def _runtime_health(release_digest: str, runtime_abi: str) -> dict[str, object]:
+    return {
+        "release_digest": release_digest,
+        "runtime_abi": runtime_abi,
+        "image_digest": os.environ.get("FUNCTIONS_RUNTIME_IMAGE_DIGEST", ""),
+        "runtime_features": [WARMED_DURABLE_EVENTS_FEATURE],
+    }
 
 
 def _elapsed_ms(started: float) -> float:

lumera-0.40.3.dev2026090401/lumera/releases/_durable_event.py

@@ -0,0 +1,116 @@
+"""Durable Function execution inside a warmed project App runtime."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+from ._worker_child import (
+    _api,
+    _claim_execution,
+    _execute_claimed_existing_release,
+    _log_event,
+)
+
+_ReadyRelease = Callable[[], Awaitable[tuple[Path, Path]]]
+
+
+async def execute_durable_event(
+    message: dict[str, object],
+    *,
+    ready_release: _ReadyRelease,
+) -> tuple[int, dict[str, object]]:
+    """Claim, then run one generation-fenced event in a killable child process."""
+
+    if message.get("event_type") != "function.execute":
+        return 400, {"error": "unsupported event"}
+    project_id = _required_string(message, "project_id")
+    execution_id = _required_string(message, "execution_id")
+    _required_string(message, "company_id")
+    _required_string(message, "worker_token")
+    release_id = _required_string(message, "release_id")
+    runtime_generation = _required_positive_int(message, "runtime_generation")
+
+    loaded_release = os.environ.get("LUMERA_RELEASE_ID", "").strip()
+    loaded_generation = os.environ.get("LUMERA_RUNTIME_GENERATION", "").strip()
+    if loaded_release != release_id or loaded_generation != str(runtime_generation):
+        _log_event(
+            "functions.app.stale_dispatch",
+            project_id=project_id,
+            execution_id=execution_id,
+            dispatch_generation=runtime_generation,
+            loaded_generation=loaded_generation,
+        )
+        return 409, {"error": "runtime generation changed"}
+
+    prefix = f"/internal/functions/projects/{project_id}/executions/{execution_id}"
+    claim, reason = await asyncio.to_thread(
+        _claim_execution,
+        prefix,
+        str(message["worker_token"]),
+        {"release_id": release_id, "runtime_generation": runtime_generation},
+        api=_api,
+    )
+    if claim is None:
+        return 202, {"accepted": False, "reason": reason or "not_claimable"}
+
+    execution = claim.get("execution")
+    if not isinstance(execution, dict):
+        raise RuntimeError("claim returned an invalid execution")
+    if (
+        str(execution.get("release_id", "")) != loaded_release
+        or int(execution.get("runtime_generation", 0)) != runtime_generation
+    ):
+        raise RuntimeError("claimed execution does not match the loaded App release")
+
+    try:
+        release_root, runtime_temporary_root = await ready_release()
+        return await asyncio.to_thread(
+            _execute_claimed_existing_release,
+            message,
+            claim,
+            root=release_root,
+            runtime_temporary_root=runtime_temporary_root,
+            api=_api,
+        )
+    except BaseException as exc:
+        _log_event(
+            "functions.app.batch_item_failed",
+            project_id=project_id,
+            execution_id=execution_id,
+            error_type=type(exc).__name__,
+        )
+        try:
+            await asyncio.to_thread(
+                _api,
+                prefix + "/failed",
+                {"lease_token": str(claim["lease_token"])},
+                str(message["worker_token"]),
+            )
+        except BaseException as recovery_exc:
+            _log_event(
+                "functions.app.failure_recovery_failed",
+                project_id=project_id,
+                execution_id=execution_id,
+                error_type=type(recovery_exc).__name__,
+            )
+        raise
+
+
+def _required_string(value: dict[str, object], key: str) -> str:
+    result = value.get(key)
+    if not isinstance(result, str) or not result.strip():
+        raise ValueError(f"{key} is required")
+    return result.strip()
+
+
+def _required_positive_int(value: dict[str, object], key: str) -> int:
+    result = value.get(key)
+    if isinstance(result, bool) or not isinstance(result, int) or result <= 0:
+        raise ValueError(f"{key} must be positive")
+    return result
+
+
+__all__ = ["execute_durable_event"]

{lumera-0.40.2.dev20260830 → lumera-0.40.3.dev2026090401}/lumera/releases/_worker_child.py

@@ -12,6 +12,7 @@ import sys
 import tempfile
 import threading
 import time
+from collections.abc import Callable
 from http.server import BaseHTTPRequestHandler, HTTPServer
 from pathlib import Path
 from urllib.error import HTTPError
@@ -20,6 +21,9 @@ from urllib.request import Request, urlopen
 
 MAX_RELEASE_BYTES = 250 * 1024 * 1024
 MAX_CHILD_OUTPUT = 1_100_000
+MAX_EXECUTION_SECONDS = 600
+
+APICall = Callable[[str, dict[str, object], str], dict[str, object]]
 
 _WORKER_TEMP_ROOT = Path(os.environ.get("LUMERA_WORKER_TEMP_ROOT", tempfile.gettempdir()))
 
@@ -78,10 +82,19 @@ def _download_release(url: str, destination: Path) -> None:
             raise RuntimeError("release archive exceeds runtime limit")
 
 
-def _purge_worker_temporary_storage() -> None:
+def _purge_worker_temporary_storage(*, preserve: tuple[Path, ...] = ()) -> None:
     """Remove all writable state left by a previous customer invocation."""
     _WORKER_TEMP_ROOT.mkdir(parents=True, exist_ok=True)
-    for child in _WORKER_TEMP_ROOT.iterdir():
+    root = _WORKER_TEMP_ROOT.resolve()
+    preserved_children: set[Path] = set()
+    for path in preserve:
+        resolved = path.resolve()
+        if resolved == root or root not in resolved.parents:
+            raise RuntimeError("preserved runtime path must be inside worker temporary storage")
+        preserved_children.add(root / resolved.relative_to(root).parts[0])
+    for child in root.iterdir():
+        if child in preserved_children:
+            continue
         if child.is_symlink() or not child.is_dir():
             child.unlink(missing_ok=True)
         else:
@@ -104,36 +117,100 @@ def _execute_message(message: dict[str, object]) -> None:
     execution_id = str(message["execution_id"])
     worker_token = str(message.get("worker_token", ""))
     prefix = f"/internal/functions/projects/{project}/executions/{execution_id}"
+    claim, _ = _claim_execution(prefix, worker_token, {}, api=_api)
+    if claim is None:
+        return
+    execution = claim.get("execution")
+    if not isinstance(execution, dict):
+        raise RuntimeError("claim returned an invalid execution")
+    # The invocation-level finally block owns cleanup. Avoid a second
+    # TemporaryDirectory finalizer racing that full /tmp purge on error paths.
+    temporary = Path(tempfile.mkdtemp(prefix="lumera-function-worker-", dir=_WORKER_TEMP_ROOT))
+    archive = temporary / "release.tar.gz"
+    root = temporary / "release"
+    _download_release(str(claim["release_url"]), archive)
+    from lumera.releases import extract_archive
+
+    extract_archive(archive, root, expected_digest=str(claim["release_digest"]))
+    _execute_claimed_release(message, claim, root, api=_api, event_namespace="functions.worker")
+
+
+def _execute_claimed_existing_release(
+    message: dict[str, object],
+    claim: dict[str, object],
+    *,
+    root: Path,
+    runtime_temporary_root: Path,
+    api: APICall,
+) -> tuple[int, dict[str, object]]:
+    """Execute an already-claimed active release with the shared process protocol."""
+
+    project = str(message["project_id"])
+    execution_id = str(message["execution_id"])
+    _purge_worker_temporary_storage(preserve=(runtime_temporary_root,))
+    try:
+        status = _execute_claimed_release(
+            message,
+            claim,
+            root,
+            api=api,
+            event_namespace="functions.app",
+        )
+        _log_event(
+            "functions.app.execution_completed",
+            project_id=project,
+            execution_id=execution_id,
+            status=status,
+        )
+        return 200, {"ok": True, "status": status}
+    finally:
+        # Preserve the loaded immutable release, but remove every other /tmp
+        # entry so Function output cannot survive into a later App invocation.
+        _purge_worker_temporary_storage(preserve=(runtime_temporary_root,))
+
+
+def _claim_execution(
+    prefix: str,
+    worker_token: str,
+    payload: dict[str, object],
+    *,
+    api: APICall,
+) -> tuple[dict[str, object] | None, str | None]:
     try:
-        claim = _api(prefix + "/claim", {}, worker_token)
+        return api(prefix + "/claim", payload, worker_token), None
     except HTTPError as exc:
-        # A duplicate SQS delivery after another worker has claimed or
-        # completed this execution is acknowledged without rerunning code.
+        # A duplicate delivery after another worker has claimed or completed
+        # this execution is acknowledged without rerunning code.
         if exc.code in {404, 409}:
-            return
+            return None, "not_claimable"
         if exc.code == 429:
             try:
-                _api(prefix + "/defer", {}, worker_token)
+                api(prefix + "/defer", {}, worker_token)
             except HTTPError as defer_exc:
                 # Capacity can become available and a duplicate delivery can
                 # claim or finish the execution between /claim and /defer.
                 if defer_exc.code not in {404, 409}:
                     raise
-            return
+            return None, "capacity"
         raise
+
+
+def _execute_claimed_release(
+    message: dict[str, object],
+    claim: dict[str, object],
+    root: Path,
+    *,
+    api: APICall,
+    event_namespace: str,
+) -> str:
+    project = str(message["project_id"])
+    execution_id = str(message["execution_id"])
+    worker_token = str(message.get("worker_token", ""))
+    prefix = f"/internal/functions/projects/{project}/executions/{execution_id}"
     lease = str(claim["lease_token"])
-    execution = claim["execution"]
+    execution = claim.get("execution")
     if not isinstance(execution, dict):
         raise RuntimeError("claim returned an invalid execution")
-    # The invocation-level finally block owns cleanup. Avoid a second
-    # TemporaryDirectory finalizer racing that full /tmp purge on error paths.
-    temporary = Path(tempfile.mkdtemp(prefix="lumera-function-worker-", dir=_WORKER_TEMP_ROOT))
-    archive = temporary / "release.tar.gz"
-    root = temporary / "release"
-    _download_release(str(claim["release_url"]), archive)
-    from lumera.releases import extract_archive
-
-    extract_archive(archive, root, expected_digest=str(claim["release_digest"]))
     child_input = _trusted_child_input(
         execution,
         company_id=str(message["company_id"]),
@@ -141,78 +218,17 @@ def _execute_message(message: dict[str, object]) -> None:
         execution_id=execution_id,
         claim=claim,
     )
-    process = subprocess.Popen(
-        [
-            sys.executable,
-            "-I",
-            "-m",
-            "lumera.releases._function_child",
-            str(root),
-            str(execution["function_key"]),
-        ],
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.DEVNULL,
-        env=_function_environment(
-            str(claim["function_token"]), str(execution.get("causation_id", ""))
-        ),
-        start_new_session=True,
-    )
-    try:
-        # The child blocks reading stdin, so this is the last pre-code boundary:
-        # extraction and spawn failures remain safely retryable.
-        _api(prefix + "/code-started", {"lease_token": lease}, worker_token)
-    except BaseException:
-        _terminate_process_group(process)
-        raise
-    child_bytes = json.dumps(child_input, separators=(",", ":")).encode("utf-8")
-    stdout = bytearray()
-
-    def drain_stdout() -> None:
-        assert process.stdout is not None
-        while chunk := process.stdout.read(64 * 1024):
-            remaining = MAX_CHILD_OUTPUT + 1 - len(stdout)
-            if remaining > 0:
-                stdout.extend(chunk[:remaining])
-
-    stdout_reader = threading.Thread(
-        target=drain_stdout,
-        name="lumera-function-stdout",
-        daemon=True,
+    stdout_bytes, timed_out = _run_function_child(
+        root=root,
+        function_key=str(execution["function_key"]),
+        child_input=child_input,
+        function_token=str(claim["function_token"]),
+        causation_id=str(execution.get("causation_id", "")),
+        prefix=prefix,
+        lease=lease,
+        worker_token=worker_token,
+        api=api,
     )
-    stdout_reader.start()
-    assert process.stdin is not None
-    try:
-        process.stdin.write(child_bytes)
-        process.stdin.close()
-    except BrokenPipeError:
-        pass
-    deadline = time.monotonic() + 600
-    timed_out = False
-    while True:
-        try:
-            process.wait(timeout=min(45, max(0.1, deadline - time.monotonic())))
-            break
-        except subprocess.TimeoutExpired:
-            if time.monotonic() >= deadline:
-                timed_out = True
-                _terminate_process_group(process)
-                break
-            # A failed heartbeat means the lease was lost or cancellation was
-            # requested. Stop code before it can continue with stale authority.
-            try:
-                _api(prefix + "/heartbeat", {"lease_token": lease}, worker_token)
-            except BaseException:
-                _terminate_process_group(process)
-                raise
-    # The entrypoint may have spawned descendants that inherited its stdout or
-    # scoped token. Retire the complete session after the entrypoint exits so a
-    # warm Lambda never carries customer processes into the next invocation.
-    _terminate_process_group(process)
-    stdout_reader.join(timeout=5)
-    if stdout_reader.is_alive():
-        raise RuntimeError("Function stdout reader did not terminate")
-    stdout_bytes = bytes(stdout)
     if timed_out:
         envelope = {
             "ok": False,
@@ -244,7 +260,12 @@ def _execute_message(message: dict[str, object]) -> None:
                     "retryable": False,
                 },
             }
-    _log_execution_timings(envelope, project_id=project, execution_id=execution_id)
+    _log_execution_timings(
+        envelope,
+        project_id=project,
+        execution_id=execution_id,
+        event_namespace=event_namespace,
+    )
     result_payload = (
         envelope.get("result") if envelope.get("ok") else {"error": envelope.get("error")}
     )
@@ -252,7 +273,7 @@ def _execute_message(message: dict[str, object]) -> None:
 
     if not envelope.get("ok"):
         _log_event(
-            "functions.worker.execution_failed",
+            event_namespace + ".execution_failed",
             project_id=project,
             execution_id=execution_id,
             error_code=str(error.get("code", "")),
@@ -266,7 +287,7 @@ def _execute_message(message: dict[str, object]) -> None:
         if envelope.get("timed_out")
         else "failed"
     )
-    uploaded = _api(
+    uploaded = api(
         prefix + "/result",
         {
             "lease_token": lease,
@@ -277,7 +298,7 @@ def _execute_message(message: dict[str, object]) -> None:
         },
         worker_token,
     )
-    _api(
+    api(
         prefix + "/complete",
         {
             "lease_token": lease,
@@ -288,6 +309,102 @@ def _execute_message(message: dict[str, object]) -> None:
         },
         worker_token,
     )
+    return terminal_status
+
+
+def _run_function_child(
+    *,
+    root: Path,
+    function_key: str,
+    child_input: dict[str, object],
+    function_token: str,
+    causation_id: str,
+    prefix: str,
+    lease: str,
+    worker_token: str,
+    api: APICall,
+) -> tuple[bytes, bool]:
+    """Run customer code in a process group that is always retired."""
+
+    _WORKER_TEMP_ROOT.mkdir(parents=True, exist_ok=True)
+    execution_temporary = Path(
+        tempfile.mkdtemp(prefix="lumera-function-execution-", dir=_WORKER_TEMP_ROOT)
+    )
+    process: subprocess.Popen[bytes] | None = None
+    stdout_reader: threading.Thread | None = None
+    stdout = bytearray()
+    timed_out = False
+    try:
+        process = subprocess.Popen(
+            [
+                sys.executable,
+                "-I",
+                "-m",
+                "lumera.releases._function_child",
+                str(root),
+                function_key,
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            cwd=execution_temporary,
+            env=_function_environment(
+                function_token,
+                causation_id,
+                temporary_directory=execution_temporary,
+            ),
+            start_new_session=True,
+        )
+        # The child blocks reading stdin, so this is the last pre-code boundary:
+        # setup failures remain safely retryable and the finally block kills it.
+        api(prefix + "/code-started", {"lease_token": lease}, worker_token)
+        child_bytes = json.dumps(child_input, separators=(",", ":")).encode("utf-8")
+
+        def drain_stdout() -> None:
+            assert process is not None and process.stdout is not None
+            while chunk := process.stdout.read(64 * 1024):
+                remaining = MAX_CHILD_OUTPUT + 1 - len(stdout)
+                if remaining > 0:
+                    stdout.extend(chunk[:remaining])
+
+        stdout_reader = threading.Thread(
+            target=drain_stdout,
+            name="lumera-function-stdout",
+            daemon=True,
+        )
+        stdout_reader.start()
+        assert process.stdin is not None
+        try:
+            process.stdin.write(child_bytes)
+            process.stdin.close()
+        except BrokenPipeError:
+            pass
+        deadline = time.monotonic() + MAX_EXECUTION_SECONDS
+        while True:
+            try:
+                process.wait(timeout=min(45, max(0.1, deadline - time.monotonic())))
+                break
+            except subprocess.TimeoutExpired:
+                if time.monotonic() >= deadline:
+                    timed_out = True
+                    break
+                # A failed heartbeat means the lease was lost or cancellation
+                # was requested. The finally block kills code before it can
+                # continue with stale authority.
+                api(prefix + "/heartbeat", {"lease_token": lease}, worker_token)
+    finally:
+        try:
+            try:
+                if process is not None:
+                    _terminate_process_group(process)
+            finally:
+                if stdout_reader is not None:
+                    stdout_reader.join(timeout=5)
+        finally:
+            shutil.rmtree(execution_temporary, ignore_errors=True)
+    if stdout_reader is not None and stdout_reader.is_alive():
+        raise RuntimeError("Function stdout reader did not terminate")
+    return bytes(stdout), timed_out
 
 
 def _trusted_child_input(
@@ -323,13 +440,20 @@ def _trusted_child_input(
     return child_input
 
 
-def _function_environment(function_token: str, causation_id: str = "") -> dict[str, str]:
+def _function_environment(
+    function_token: str,
+    causation_id: str = "",
+    *,
+    temporary_directory: Path | None = None,
+) -> dict[str, str]:
     if not function_token:
         raise RuntimeError("nested Function invocation token is unavailable")
     environment = {
         key: value for key in _CHILD_ENVIRONMENT_KEYS if (value := os.environ.get(key)) is not None
     }
     environment["LUMERA_TOKEN"] = function_token
+    if temporary_directory is not None:
+        environment["TMPDIR"] = str(temporary_directory)
     if causation_id:
         environment["LUMERA_CAUSATION_ID"] = causation_id
     return environment
@@ -340,6 +464,7 @@ def _log_execution_timings(
     *,
     project_id: str,
     execution_id: str,
+    event_namespace: str = "functions.worker",
 ) -> None:
     if not isinstance(envelope, dict) or not isinstance(envelope.get("timings_ms"), dict):
         return
@@ -362,7 +487,7 @@ def _log_execution_timings(
     }
     if timings:
         _log_event(
-            "functions.worker.execution_timing",
+            event_namespace + ".execution_timing",
             project_id=project_id,
             execution_id=execution_id,
             **timings,

{lumera-0.40.2.dev20260830 → lumera-0.40.3.dev2026090401}/lumera.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lumera
-Version: 0.40.2.dev20260830
+Version: 0.40.3.dev2026090401
 Summary: SDK for building on Lumera platform
 Requires-Python: >=3.11
 Requires-Dist: requests

{lumera-0.40.2.dev20260830 → lumera-0.40.3.dev2026090401}/lumera.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ lumera/releases/_archive.py
 lumera/releases/_builder.py
 lumera/releases/_config.py
 lumera/releases/_contracts.py
+lumera/releases/_durable_event.py
 lumera/releases/_errors.py
 lumera/releases/_function_child.py
 lumera/releases/_projection.py

{lumera-0.40.2.dev20260830 → lumera-0.40.3.dev2026090401}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lumera"
-version = "0.40.2.dev20260830"
+version = "0.40.3.dev2026090401"
 description = "SDK for building on Lumera platform"
 requires-python = ">=3.11"
 dependencies = [