@fireemu/darwin-x64 0.43.0 → 0.44.0

package/bin/runner-python/fireemu_runner/events.py

@@ -10,11 +10,25 @@ dict (`firestore_fn.py:108-131`). The adapter therefore builds the production fo
 import json
 import os
 import re
+from typing import NamedTuple
 
 from cloudevents.http import from_http
 from google.events.cloud import firestore as firestore_events
 
+from . import bodies
+
 _NOT_AN_ATTRIBUTE = frozenset({"data", "datacontenttype"})
+# The daemon's strict 2nd gen frame names a `traceparent` for the Node runner's event. Production sends the trace context as an
+# ordinary HTTP header (Cloud Run's), never as a `ce-` attribute, so the strict Python event has none (sandbox run
+# PYCHECK-EVENTS-20261104-01, the raw twins of the Pub/Sub, Storage, Eventarc and Firestore events). The emulator profile
+# stamps no such member, so a `traceparent` there is the publisher's own tracing extension and stays an attribute.
+_HTTP_HEADER_ONLY = frozenset({"traceparent"})
+# Eventarc sends `ce-dataschema` with every Firestore event. Recorded for `created` only; for `updated`, `deleted`, `written`
+# and any other type routed here it is UNRECORDED (the schema is one document for the family in google-cloudevents). The strict
+# profile delivers it; the emulator profile keeps the official emulator's attributes, which have none.
+_FIRESTORE_DATASCHEMA = (
+    "https://github.com/googleapis/google-cloudevents/blob/main/proto/google/events/cloud/firestore/v1/data.proto"
+)
 
 
 _WHOLE_SECOND_TIME = re.compile(r"^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(Z|[+-]\d{2}:\d{2})$")
@@ -25,10 +39,11 @@ def _attribute_headers(event: dict) -> dict:
     if not isinstance(event.get("specversion"), str):
         # Without it `from_http` would read the body as a structured JSON event and fail on the body.
         raise ValueError("the event has no specversion")
+    header_only = _HTTP_HEADER_ONLY if is_strict() else frozenset()
     return {
         f"ce-{name}": value
         for name, value in event.items()
-        if name not in _NOT_AN_ATTRIBUTE and isinstance(value, str)
+        if name not in _NOT_AN_ATTRIBUTE and name not in header_only and isinstance(value, str)
     }
 
 
@@ -37,24 +52,52 @@ def _is_json(content_type: str) -> bool:
     return media == "application/json" or media.endswith("+json")
 
 
-def _json_cloud_event(event: dict):
-    """The `CloudEvent` for an event whose data is JSON (or text, with a text content type).
+class Delivery(NamedTuple):
+    """One delivery: the headers, the body the event is built from, and the body the request carries.
+
+    The two bodies are the same bytes for a Firestore event. For the JSON families the event is built from the encoding of
+    the data the adapters have always used (`event_body`), and the request shows the layout the recorded delivery had
+    (`request_body`); the function is given the same event whichever layout the request has.
+    """
+
+    headers: dict
+    event_body: bytes
+    request_body: bytes
+
+
+def _json_delivery(event: dict, request_text: str | None = None) -> Delivery:
+    """The delivery of an event whose data is JSON (or text, with a text content type).
 
     Eventarc delivers these in binary content mode: attributes as `ce-*` headers and the data as the body,
     which functions-framework hands to `cloudevents.http.from_http` (`functions_framework/__init__.py:174-188`).
-    A delivery without a content type is JSON.
+    A delivery without a content type is JSON. `request_text` is the body text of the request when it differs from the
+    compact encoding of the data (see `bodies.py`).
     """
     headers = _attribute_headers(event)
     declared = event.get("datacontenttype")
     content_type = declared if isinstance(declared, str) and declared else "application/json"
     headers["content-type"] = content_type
     if "data" not in event:
-        body = b""
-    elif isinstance(event["data"], str) and not _is_json(content_type):
+        return Delivery(headers, b"", b"")
+    if isinstance(event["data"], str) and not _is_json(content_type):
         body = event["data"].encode()
-    else:
-        body = json.dumps(event["data"]).encode()
-    return from_http(headers, body)
+        return Delivery(headers, body, body)
+    request = request_text if request_text is not None else bodies.compact(event["data"])
+    return Delivery(headers, json.dumps(event["data"]).encode(), request.encode())
+
+
+def _delivered_value(event: dict, raw_data: str | None):
+    """The data with its numbers as the daemon wrote them, or the event's own data when there is no text or it does not parse."""
+    if raw_data is not None:
+        try:
+            return bodies.parse_keeping_numbers(raw_data)
+        except ValueError:
+            pass
+    return event.get("data")
+
+
+def is_strict() -> bool:
+    return os.environ.get("FIREEMU_HTTP_PROFILE") == "strict"
 
 
 def _lenient_time(event: dict) -> dict:
@@ -65,49 +108,96 @@ def _lenient_time(event: dict) -> dict:
     emulator profile must serve; the strict profile delivers the time as production's event has it.
     """
     time = event.get("time")
-    if os.environ.get("FIREEMU_HTTP_PROFILE", "emulator") == "strict" or not isinstance(time, str):
+    if is_strict() or not isinstance(time, str):
         return event
     match = _WHOLE_SECOND_TIME.match(time)
     return event if match is None else {**event, "time": f"{match.group(1)}.000{match.group(2)}"}
 
 
-def pubsub_cloud_event(event: dict):
-    """The `CloudEvent` for a Pub/Sub message event.
-
-    The SDK reads `message_id` and `publish_time` (`pubsub_fn.py:98-160`), the snake-case spellings Pub/Sub's
-    push body carries next to `messageId` and `publishTime`. `orderingKey` has no alternative: the SDK pops
-    it and passes `ordering_key=` itself, so a copied key would be passed twice (`TypeError`).
-    """
-    data = event.get("data")
+def _with_snake_case_keys(data):
+    """A Pub/Sub push body with `message_id` and `publish_time` next to `messageId` and `publishTime` (`pubsub_fn.py:98-160`)."""
     message = data.get("message") if isinstance(data, dict) else None
     if not isinstance(message, dict):
-        return _json_cloud_event(event)
+        return data
     message = dict(message)
     for camel, snake in (("messageId", "message_id"), ("publishTime", "publish_time")):
         if snake not in message and camel in message and message[camel] is not None:
             message[snake] = message[camel]
-    return _json_cloud_event({**event, "data": {**data, "message": message}})
+    return {**data, "message": message}
+
+
+def pubsub_request(event: dict, raw_data: str | None = None) -> Delivery:
+    """The delivery of a Pub/Sub message event.
+
+    The SDK reads `message_id` and `publish_time` (`pubsub_fn.py:98-160`), the snake-case spellings Pub/Sub's
+    push body carries next to `messageId` and `publishTime`. `orderingKey` has no alternative: the SDK pops
+    it and passes `ordering_key=` itself, so a copied key would be passed twice (`TypeError`).
+    The strict request carries the recorded layout: sorted compact JSON and a newline.
+    """
+    data = event.get("data")
+    if not isinstance(data, dict) or not isinstance(data.get("message"), dict):
+        return _json_delivery(event)
+    event = {**event, "data": _with_snake_case_keys(data)}
+    value = _with_snake_case_keys(_delivered_value(event, raw_data))
+    text = bodies.pubsub_layout(value) if is_strict() else bodies.compact(value)
+    return _json_delivery(event, text)
+
+
+def storage_request(event: dict, raw_data: str | None = None) -> Delivery:
+    """The delivery of a Storage object event: the text the daemon sent, and in the strict profile the recorded layout."""
+    event = _lenient_time(event)
+    if is_strict() and "data" in event:
+        return _json_delivery(event, bodies.storage_layout(_delivered_value(event, raw_data)))
+    return _json_delivery(event, raw_data)
+
+
+def eventarc_request(event: dict, raw_data: str | None = None) -> Delivery:
+    """The delivery of a custom Eventarc event: the text of the data as the daemon framed it (the publisher's own in the strict profile)."""
+    return _json_delivery(_lenient_time(event), raw_data)
+
+
+def database_request(event: dict, raw_data: str | None = None) -> Delivery:
+    """The delivery of a Realtime Database event: the text the daemon sent (no raw delivery was recorded; UNRECORDED)."""
+    return _json_delivery(event, raw_data)
+
+
+def firestore_request(event: dict, raw_data: str | None = None) -> Delivery:
+    """The delivery of a Firestore event frame (`created`, `updated`, `deleted`, `written`): a protobuf body."""
+    headers = _attribute_headers(event)
+    if is_strict():
+        headers.setdefault("ce-dataschema", _FIRESTORE_DATASCHEMA)
+    data = event.get("data")
+    message = firestore_events.DocumentEventData.from_json(json.dumps(data if isinstance(data, dict) else {}))
+    headers["content-type"] = "application/protobuf"
+    body = firestore_events.DocumentEventData.serialize(message)
+    return Delivery(headers, body, body)
+
+
+def pubsub_cloud_event(event: dict):
+    """The `CloudEvent` for a Pub/Sub message event (see `pubsub_request`)."""
+    delivery = pubsub_request(event)
+    return from_http(delivery.headers, delivery.event_body)
 
 
 def storage_cloud_event(event: dict):
     """The `CloudEvent` for a Storage object event."""
-    return _json_cloud_event(_lenient_time(event))
+    delivery = storage_request(event)
+    return from_http(delivery.headers, delivery.event_body)
 
 
 def eventarc_cloud_event(event: dict):
     """The `CloudEvent` for a custom Eventarc event."""
-    return _json_cloud_event(_lenient_time(event))
+    delivery = eventarc_request(event)
+    return from_http(delivery.headers, delivery.event_body)
 
 
 def database_cloud_event(event: dict):
     """The `CloudEvent` for a Realtime Database event."""
-    return _json_cloud_event(event)
+    delivery = database_request(event)
+    return from_http(delivery.headers, delivery.event_body)
 
 
 def firestore_cloud_event(event: dict):
     """The `CloudEvent` for a Firestore event frame (`created`, `updated`, `deleted`, `written`)."""
-    headers = _attribute_headers(event)
-    data = event.get("data")
-    message = firestore_events.DocumentEventData.from_json(json.dumps(data if isinstance(data, dict) else {}))
-    headers["content-type"] = "application/protobuf"
-    return from_http(headers, firestore_events.DocumentEventData.serialize(message))
+    delivery = firestore_request(event)
+    return from_http(delivery.headers, delivery.event_body)

package/bin/runner-python/fireemu_runner/framing.py

@@ -27,13 +27,59 @@ def encode_frame(message: dict) -> bytes:
     return str(len(payload)).encode("ascii") + b"\n" + payload
 
 
+_DECODER = json.JSONDecoder()
+_WHITESPACE = " \t\n\r"
+# The trigger types whose request body is the event's JSON data as the daemon framed it.
+_RAW_DATA_TRIGGERS = frozenset(("eventarc", "pubsub", "storage", "database"))
+
+
+def _after_whitespace(text: str, index: int) -> int:
+    while index < len(text) and text[index] in _WHITESPACE:
+        index += 1
+    return index
+
+
+def raw_event_data(text: str) -> str | None:
+    """The text of `event.data` exactly as it stands in a frame, or None when the frame has none or is malformed.
+
+    The decoder turns the data into Python values and forgets its spelling (`1e-7`, `\\u00e9`, member order, white space).
+    For a custom Eventarc event in the strict profile the daemon frames the publisher's own JSON text, and that text is the
+    request body production delivered, so it is read here from the frame text, member by member, without parsing the data.
+    """
+    try:
+        index = _after_whitespace(text, 0)
+        for wanted in ("event", "data"):
+            if text[index] != "{":
+                return None
+            index += 1
+            while True:
+                index = _after_whitespace(text, index)
+                key, index = _DECODER.raw_decode(text, index)
+                index = _after_whitespace(text, index)
+                if text[index] != ":" or not isinstance(key, str):
+                    return None
+                index = _after_whitespace(text, index + 1)
+                if key == wanted:
+                    break
+                index = _after_whitespace(text, _DECODER.raw_decode(text, index)[1])
+                if text[index] == ",":
+                    index += 1
+        start = index
+        end = _DECODER.raw_decode(text, start)[1]
+        # A value must be followed by what ends it, or the frame is cut short.
+        return text[start:end] if text[_after_whitespace(text, end)] in ",}" else None
+    except (IndexError, ValueError):
+        return None
+
+
 def _text(value) -> bool:
     return isinstance(value, str) and len(value) > 0
 
 
 def _decode_message(payload: bytes) -> dict:
     try:
-        message = json.loads(payload.decode("utf-8"))
+        text = payload.decode("utf-8")
+        message = json.loads(text)
     except (UnicodeDecodeError, ValueError):
         raise ProtocolError("UTF-8 or JSON") from None
     if not isinstance(message, dict):
@@ -49,6 +95,10 @@ def _decode_message(payload: bytes) -> dict:
         or ("entryPoint" in message and not _text(message["entryPoint"]))
     ):
         raise ProtocolError("message fields")
+    if message["trigger"] in _RAW_DATA_TRIGGERS and "data" in message["event"]:
+        raw = raw_event_data(text)
+        if raw is not None:
+            message["rawEventData"] = raw
     return message
 
 

package/bin/runner-python/fireemu_runner/main.py

@@ -6,10 +6,12 @@ import platform
 import sys
 import traceback
 
+from . import appcheck
 from .dispatch import Dispatcher
+from .environment import EnvironmentGate, load_local_secrets
 from .framing import FrameWriter, ProtocolError, read_frame
 from .manifest import build_manifest
-from .serve import start_server
+from .serve import HTTP_TRIGGERS, start_server
 
 
 def _parse(argv):
@@ -27,13 +29,15 @@ def load_codebase(source: str) -> dict:
     return serving.get_functions()
 
 
-def serve(functions: dict, codebase: str, secret: str, stdin, writer: FrameWriter) -> int:
+def serve(
+    functions: dict, codebase: str, secret: str, stdin, writer: FrameWriter, gate: EnvironmentGate | None = None, app_check_verified: bool = False
+) -> int:
     """Says hello, then serves frames from `stdin` until `shutdown` or the end of the stream."""
-    manifest = build_manifest(functions)
+    manifest = build_manifest(functions, app_check_verified)
     server = None
     port = None
-    if any(spec["trigger"]["type"] == "http" for spec in manifest["functions"]):
-        server, port = start_server(functions, manifest, secret)
+    if any(spec["trigger"]["type"] in HTTP_TRIGGERS for spec in manifest["functions"]):
+        server, port = start_server(functions, manifest, secret, gate)
     writer.write(
         {
             "type": "hello",
@@ -44,7 +48,7 @@ def serve(functions: dict, codebase: str, secret: str, stdin, writer: FrameWrite
             "manifest": manifest,
         }
     )
-    dispatcher = Dispatcher(functions, manifest, writer)
+    dispatcher = Dispatcher(functions, manifest, writer, gate)
     try:
         while True:
             message = read_frame(stdin)
@@ -70,13 +74,19 @@ def run(argv) -> int:
     os.dup2(2, 1)
     writer = FrameWriter(protocol)
     secret = os.environ.get("FIREEMU_RUNNER_SECRET", "")
-    # The daemon's local secrets are for the SDK's parameter lookup; user code does not see the channel
-    # that carried them, nor the key to this runner's HTTP port.
-    os.environ.pop("FIREEMU_LOCAL_SECRETS_JSON", None)
+    # The daemon's local secrets are put back into the environment, a function at a time, by the gate; user code
+    # does not see the channel that carried them, nor the key to this runner's HTTP port.
     os.environ.pop("FIREEMU_RUNNER_SECRET", None)
+    try:
+        gate = EnvironmentGate(load_local_secrets(os.environ))
+    except ValueError as error:
+        sys.stderr.write(f"[functions] {error}\n")
+        return 1
+    # Before any user code runs, so the Admin SDK's App Check service is built against the emulator's keys.
+    app_check_verified = appcheck.install_from_environment(os.environ)
     try:
         functions = load_codebase(args.source)
     except BaseException:  # a failing import in user code is reported with its traceback
         traceback.print_exc()
         return 1
-    return serve(functions, args.codebase, secret, sys.stdin.buffer, writer)
+    return serve(functions, args.codebase, secret, sys.stdin.buffer, writer, gate, app_check_verified)

package/bin/runner-python/fireemu_runner/manifest.py

@@ -10,6 +10,7 @@ under `ignored[]`, never dropped.
 """
 
 import enum
+import math
 from typing import Any
 
 from firebase_functions.params import Expression
@@ -32,7 +33,10 @@ _UNSERVED_PRODUCTS = (
     ("analytics", "analytics", "notPlanned", "not planned: Google Analytics triggers have no local emulator"),
     ("testing", "testLab", "notPlanned", "not planned: Test Lab triggers have no local emulator"),
 )
-_PLANNED = "Python {family} triggers are planned for a later slice and are not served yet"
+_SCHEDULE_RETRY_FIELDS = frozenset(("retryCount", "maxRetrySeconds", "minBackoffSeconds", "maxBackoffSeconds", "maxDoublings"))
+_TASK_RETRY_FIELDS = frozenset(("maxAttempts", "maxRetrySeconds", "minBackoffSeconds", "maxBackoffSeconds", "maxDoublings"))
+_TASK_RATE_FIELDS = frozenset(("maxConcurrentDispatches", "maxDispatchesPerSecond"))
+_BLOCKING_AUTH_EVENTS = ("beforeCreate", "beforeSignIn", "beforeSendEmail", "beforeSendSms")
 
 
 class Unserved(Exception):
@@ -224,7 +228,79 @@ def _event_trigger(event_trigger: dict) -> dict:
     raise Unserved(family, "unsupported", f"event type {event_type} is not recognised")
 
 
-def describe_endpoint(name: str, endpoint) -> dict:
+def _record(value, field: str, family: str) -> dict:
+    """An options record: absent is empty, an object is itself, anything else is an error."""
+    if _unset(value):
+        return {}
+    if not isinstance(value, dict):
+        raise Unserved(family, "unsupported", f"{field} must be an object")
+    return value
+
+
+def _numbers(value, field: str, allowed: frozenset, family: str) -> dict:
+    """The numbers of a retry or rate record. A member the SDK left unset is null on the wire."""
+    record = _record(value, field, family)
+    numbers: dict[str, Any] = {}
+    for key, original in record.items():
+        if key not in allowed:
+            raise Unserved(family, "unsupported", f"{field}.{key} is not supported")
+        resolved = _resolved(original, f"{field}.{key}")
+        if resolved is None:
+            numbers[key] = None
+            continue
+        if isinstance(resolved, bool) or not isinstance(resolved, (int, float)) or not math.isfinite(resolved):
+            raise Unserved(family, "unsupported", f"{field}.{key} did not resolve to a finite number")
+        numbers[key] = resolved
+    return numbers
+
+
+def _schedule_trigger(trigger) -> tuple[dict, bool]:
+    """The canonical trigger of a `scheduleTrigger` and whether the function retries."""
+    record = _record(trigger, "scheduleTrigger", "schedule")
+    schedule = _text(record, "schedule", "scheduleTrigger.schedule", "schedule", required=True, allow_empty=False)
+    time_zone = _text(record, "timeZone", "scheduleTrigger.timeZone", "schedule")
+    # The SDK keeps a deployment expression as braced CEL; this runner resolves values, it does not evaluate CEL.
+    if "{{" in schedule or (time_zone is not None and "{{" in time_zone):
+        raise Unserved("schedule", "unsupported", "scheduleTrigger contains an unresolved deployment expression")
+    retry_config = _numbers(record.get("retryConfig"), "scheduleTrigger.retryConfig", _SCHEDULE_RETRY_FIELDS, "schedule")
+    # A Gen2 job with a retry window and no count is retried until the window ends (run 156715222b86ea44), so a
+    # window alone declares a retry too.
+    retry = (retry_config.get("retryCount") or 0) > 0 or (retry_config.get("maxRetrySeconds") or 0) > 0
+    described: dict[str, Any] = {"type": "schedule", "schedule": schedule}
+    if time_zone is not None:
+        described["timeZone"] = time_zone
+    described["retryConfig"] = retry_config
+    return described, retry
+
+
+def _task_queue_trigger(queue) -> dict:
+    record = _record(queue, "taskQueueTrigger", "tasks")
+    return {
+        "type": "tasks",
+        "retryConfig": _numbers(record.get("retryConfig"), "taskQueueTrigger.retryConfig", _TASK_RETRY_FIELDS, "tasks"),
+        "rateLimits": _numbers(record.get("rateLimits"), "taskQueueTrigger.rateLimits", _TASK_RATE_FIELDS, "tasks"),
+    }
+
+
+def _blocking_trigger(blocking) -> dict:
+    record = _record(blocking, "blockingTrigger", "blocking")
+    event_type = str(_resolved(record.get("eventType"), "blockingTrigger.eventType") or "")
+    if not any(event_type.endswith(event) for event in _BLOCKING_AUTH_EVENTS):
+        for fragment, trigger_type, scope, reason in _UNSERVED_PRODUCTS:
+            if fragment in event_type:
+                raise Unserved(trigger_type, scope, reason)
+        raise Unserved("blocking", "unsupported", f"blocking identity event {event_type} is not served")
+    options = record.get("options") if isinstance(record.get("options"), dict) else {}
+    return {
+        "type": "blockingAuth",
+        "eventType": event_type,
+        "accessToken": options.get("accessToken") is True,
+        "idToken": options.get("idToken") is True,
+        "refreshToken": options.get("refreshToken") is True,
+    }
+
+
+def describe_endpoint(name: str, endpoint, app_check_verified: bool = False) -> dict:
     """The canonical `functions[]` entry of one endpoint, or `Unserved` when it cannot be served."""
     if endpoint.platform != "gcfv2":
         raise Unserved("unknown", "unsupported", "endpoint platform is not recognised")
@@ -242,15 +318,19 @@ def describe_endpoint(name: str, endpoint) -> dict:
     if options:
         described["platformOptions"] = options
     if endpoint.taskQueueTrigger is not None:
-        raise Unserved("tasks", "planned", _PLANNED.format(family="task queue"))
+        described["trigger"] = _task_queue_trigger(endpoint.taskQueueTrigger)
+        return described
     if endpoint.httpsTrigger is not None:
         described["trigger"] = {"type": "http", "callable": False}
     elif endpoint.callableTrigger is not None:
         described["trigger"] = {"type": "http", "callable": True}
+        if app_check_verified:
+            # The SDK verifies the token itself, against the App Check emulator's keys, and never consumes it.
+            described["trigger"]["consumeAppCheckToken"] = "disabled"
     elif endpoint.scheduleTrigger is not None:
-        raise Unserved("schedule", "planned", _PLANNED.format(family="schedule"))
+        described["trigger"], described["retry"] = _schedule_trigger(endpoint.scheduleTrigger)
     elif endpoint.blockingTrigger is not None:
-        raise Unserved("blockingAuth", "planned", _PLANNED.format(family="Auth blocking"))
+        described["trigger"] = _blocking_trigger(endpoint.blockingTrigger)
     elif endpoint.eventTrigger is not None:
         described["trigger"] = _event_trigger(endpoint.eventTrigger)
         retry = _resolved(endpoint.eventTrigger.get("retry"), "eventTrigger.retry")
@@ -262,14 +342,17 @@ def describe_endpoint(name: str, endpoint) -> dict:
     return described
 
 
-def build_manifest(functions: dict) -> dict:
-    """`{"functions": [...], "ignored": [...]}` for the decorated functions of a codebase."""
+def build_manifest(functions: dict, app_check_verified: bool = False) -> dict:
+    """`{"functions": [...], "ignored": [...]}` for the decorated functions of a codebase.
+
+    `app_check_verified` says the Admin SDK verifies App Check tokens against the emulator's keys (`appcheck.py`).
+    """
     served: list[dict] = []
     ignored: list[dict] = []
     for name, function in functions.items():
         endpoint = function.__firebase_endpoint__
         try:
-            served.append(describe_endpoint(name, endpoint))
+            served.append(describe_endpoint(name, endpoint, app_check_verified))
         except Unserved as unserved:
             try:
                 region = _first_region(endpoint) or DEFAULT_REGION

package/bin/runner-python/fireemu_runner/request_view.py

@@ -0,0 +1,65 @@
+"""The HTTP request a CloudEvent function runs inside.
+
+functions-framework serves a CloudEvent function from a Flask view and calls the function inside the request context, so
+`flask.request` shows the delivered request. Production's raw twins were recorded on 2026-11-04 (sandbox run
+PYCHECK-EVENTS-20261104-01): `POST /` with the binary-mode `ce-*` headers, `content-type`, `content-length` and, in the strict
+profile, constants every recorded frame carries (the sender's user agent, the encodings, the protocol) plus Cloud Run's plain
+`traceparent` header. The body is the text the delivery had, not a re-encoding of the event: the layouts recorded per family are in
+`bodies.py` (strict Pub/Sub and Storage; Eventarc keeps the publisher's text), and the emulator and unset profiles carry the framed JSON value text
+of the data as the daemon sent it (a publisher's surrounding white space is trimmed upstream; a Pub/Sub body is the exception, it gets the SDK's snake-case aliases and is rewritten compactly). A Realtime Database body was not recorded. Header policy: a name that is not an HTTP token (or has an underscore) is
+left out of the request, a control character other than TAB in a value becomes a space, and of two names that differ only in case the first one
+is the header; the event the function receives is never changed by the view. The OIDC `Authorization`, `Forwarded`, `X-Forwarded-For`, `Function-Execution-Id`, `X-Cloud-Trace-Context`,
+`From`, `Accept` and the Cloud Run host have no local source and are not invented.
+"""
+
+import contextlib
+import re
+
+import flask
+from werkzeug.test import EnvironBuilder
+
+from .events import is_strict
+
+_APP = flask.Flask("fireemu-cloudevent")
+# What an HTTP header may be called: a token without an underscore. Header names with an underscore are dropped by the usual
+# servers, and Werkzeug folds `foo_bar` into `foo-bar`; both are UNRECORDED, so such an attribute stays out of the request
+# (the event keeps it).
+_HEADER_NAME = re.compile(r"[!#$%&'*+.^`|~0-9A-Za-z-]+")
+# A control character other than the tab cannot be in a header value; it becomes a space, as a line break does.
+_CONTROL = re.compile(r"[\x00-\x08\x0a-\x1f\x7f]")
+# Constant in every recorded Eventarc delivery (the four raw twins of run 57ab27296dedaedc).
+_STRICT_CONSTANTS = {
+    "user-agent": "APIs-Google; (+https://developers.google.com/webmasters/APIs-Google.html)",
+    "accept-encoding": "gzip, deflate, br",
+    "x-forwarded-proto": "https",
+}
+
+
+def request_headers(headers: dict, event: dict) -> dict:
+    """The headers of the request: the event's binary-mode headers, and in the strict profile the recorded constants and the
+    trace context as the plain `traceparent` header.
+
+    The request is what a server would have received, so a name that is not a header name is left out, and when two names
+    differ only in case the first one stays. A control character in a value other than the tab, a line break included, is
+    replaced by a space. The event the function receives keeps every attribute and its text.
+    """
+    view = {}
+    taken = set()
+    for name, value in headers.items():
+        if _HEADER_NAME.fullmatch(name) and name.lower() not in taken:
+            taken.add(name.lower())
+            view[name] = _CONTROL.sub(" ", value)
+    if is_strict():
+        view.update(_STRICT_CONSTANTS)
+        traceparent = event.get("traceparent")
+        if isinstance(traceparent, str):
+            view["traceparent"] = _CONTROL.sub(" ", traceparent)
+    return view
+
+
+@contextlib.contextmanager
+def delivery_request(headers: dict, body: bytes, event: dict):
+    """Runs the block inside the Flask request context of the delivery described by `headers` and `body`."""
+    environ = EnvironBuilder(method="POST", path="/", headers=request_headers(headers, event), data=body).get_environ()
+    with _APP.request_context(environ):
+        yield

package/bin/runner-python/fireemu_runner/scheduler.py

@@ -0,0 +1,87 @@
+"""Scheduled runs: the request Cloud Scheduler sends a Gen2 function, built in process.
+
+A Gen2 `on_schedule` function is an HTTP function. Production's Scheduler calls it with `POST /`, the job id in
+`X-CloudScheduler-JobName` and the schedule time in `X-CloudScheduler-ScheduleTime`, and judges the attempt by the
+status the SDK wrapper answers: 200, or 500 when the handler raised (the wrapper logs the error and answers its
+message, `scheduler_fn.py:99-137`). The Node runner does the same in the strict profile
+(`tools/runner-node/schedule-delivery.mjs`, recorded in run 156715222b86ea44).
+"""
+
+import datetime
+import os
+import re
+from zoneinfo import ZoneInfo
+
+import flask
+from werkzeug.test import EnvironBuilder
+
+_INSTANT = re.compile(r"^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(?:\.(\d{1,9}))?Z$")
+_LOS_ANGELES = ZoneInfo("America/Los_Angeles")
+_JOB_NAME = re.compile(r"projects/([^/]*)/locations/([^/]*)/jobs/")
+_NAME = re.compile(r"[A-Za-z0-9-]+")
+_MAX_ANSWER_CHARS = 256
+
+
+class SchedulerFailure(Exception):
+    """A scheduled attempt that failed: the run was malformed or the function answered 400 or more."""
+
+
+def _schedule_time(instant) -> str:
+    """The schedule time as the header carries it: Los Angeles with its offset in the strict profile (whatever the
+    job's own zone, as recorded), the daemon's UTC instant otherwise."""
+    match = _INSTANT.match(instant) if isinstance(instant, str) else None
+    if match is None:
+        raise SchedulerFailure(f"the scheduled time is not an RFC 3339 UTC instant: {instant!r}")
+    year, month, day, hour, minute, second = (int(part) for part in match.groups()[:6])
+    try:
+        moment = datetime.datetime(year, month, day, hour, minute, second, tzinfo=datetime.timezone.utc)
+    except ValueError:
+        raise SchedulerFailure(f"the scheduled time is not an RFC 3339 UTC instant: {instant!r}") from None
+    if os.environ.get("FIREEMU_HTTP_PROFILE", "emulator") != "strict":
+        return instant
+    local = moment.astimezone(_LOS_ANGELES)
+    fraction = (match.group(7) or "").rstrip("0")
+    offset = local.strftime("%z")
+    return local.strftime("%Y-%m-%dT%H:%M:%S") + (f".{fraction}" if fraction else "") + f"{offset[:3]}:{offset[3:]}"
+
+
+def _function_host(job: str) -> str | None:
+    """The public host of a function, `<region>-<project>.cloudfunctions.net`, from a job's resource name.
+
+    Recorded for us-central1 only (all 76 distinct Gen2 frames of run 156715222b86ea44); another region follows the
+    same rule, unrecorded. A name without a project and a location in this form invents no host (the Node runner's
+    `functionHost`).
+    """
+    match = _JOB_NAME.match(job)
+    if match is None or not _NAME.fullmatch(match.group(1)) or not _NAME.fullmatch(match.group(2)):
+        return None
+    return f"{match.group(2)}-{match.group(1)}.cloudfunctions.net"
+
+
+def scheduler_headers(data) -> dict:
+    """The headers of the request for one scheduled run (`{jobName, scheduleTime}`)."""
+    job = data.get("jobName") if isinstance(data, dict) else None
+    if not isinstance(job, str) or not job:
+        raise SchedulerFailure("the scheduled run names no job name")
+    host = _function_host(job)
+    return {
+        "x-cloudscheduler": "true",
+        "x-cloudscheduler-jobname": job.rsplit("/", 1)[-1],
+        "x-cloudscheduler-scheduletime": _schedule_time(data.get("scheduleTime")),
+        "user-agent": "Google-Cloud-Scheduler",
+        "content-length": "0",
+        # Constant in every recorded frame: the front end's encodings and protocol.
+        "accept-encoding": "gzip, deflate, br",
+        "x-forwarded-proto": "https",
+        **({"host": host} if host else {}),
+    }
+
+
+def deliver_schedule(function, data) -> None:
+    """Calls the SDK wrapper with the scheduler's request. Returns when it answers below 400; raises otherwise."""
+    environ = EnvironBuilder(method="POST", path="/", headers=scheduler_headers(data)).get_environ()
+    with flask.Flask("fireemu-scheduler").request_context(environ):
+        response = function(flask.request)
+    if response.status_code >= 400:
+        body = response.get_data(as_text=True)[:_MAX_ANSWER_CHARS]
+        raise SchedulerFailure(f"the scheduled function answered {response.status_code}" + (f": {body}" if body else ""))