volcano-sdk-python 0.9.2__tar.gz → 0.9.3__tar.gz

volcano_sdk_python-0.9.3/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.9.3"
+}

{volcano_sdk_python-0.9.2 → volcano_sdk_python-0.9.3}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.9.3](https://github.com/Kong/volcano-sdk-python/compare/v0.9.2...v0.9.3) (2026-09-18)
+
+
+### Bug Fixes
+
+* **functions:** recover rejected user sessions before dispatch ([#173](https://github.com/Kong/volcano-sdk-python/issues/173)) ([ab76b7f](https://github.com/Kong/volcano-sdk-python/commit/ab76b7f6448022fb2101cff5382fdfdac1861c26))
+
 ## [0.9.2](https://github.com/Kong/volcano-sdk-python/compare/v0.9.1...v0.9.2) (2026-09-18)
 
 

{volcano_sdk_python-0.9.2 → volcano_sdk_python-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: volcano-sdk-python
-Version: 0.9.2
+Version: 0.9.3
 Summary: Official Python SDK for Volcano
 Project-URL: Homepage, https://volcano.dev
 Project-URL: Repository, https://github.com/Kong/volcano-sdk-python
@@ -224,8 +224,16 @@ user session; the function receives no user identity. The immutable result
 includes the response body, status, headers, and `X-Volcano-Version`. The body
 can be a JSON object, array, scalar, or text; an empty body returns `None`.
 JSON arrays become immutable tuples. Invalid JSON is returned as text. A
-function's own non-2xx response is returned when the version header proves it
-ran; platform failures raise typed SDK errors.
+function's own non-2xx response is returned when Volcano confirms it ran;
+non-success platform HTTP responses raise typed SDK errors.
+
+
+Function resolution and invocation recover from a platform HTTP 401 before dispatch:
+the SDK refreshes the captured session and retries the rejected request once.
+Concurrent calls share successful recovery. Replacing or signing out that session
+prevents replay under another identity. The call preserves its original payload values.
+A function's own response, HTTP 403, or a network failure never triggers this retry.
+Anonymous and service keys do not refresh.
 
 `logs.search()` returns an immutable page of retained runtime or deployment log
 events. Pass `next_cursor` back as `cursor` to continue a search. `logs.activity()`

{volcano_sdk_python-0.9.2 → volcano_sdk_python-0.9.3}/README.md

@@ -202,8 +202,16 @@ user session; the function receives no user identity. The immutable result
 includes the response body, status, headers, and `X-Volcano-Version`. The body
 can be a JSON object, array, scalar, or text; an empty body returns `None`.
 JSON arrays become immutable tuples. Invalid JSON is returned as text. A
-function's own non-2xx response is returned when the version header proves it
-ran; platform failures raise typed SDK errors.
+function's own non-2xx response is returned when Volcano confirms it ran;
+non-success platform HTTP responses raise typed SDK errors.
+
+
+Function resolution and invocation recover from a platform HTTP 401 before dispatch:
+the SDK refreshes the captured session and retries the rejected request once.
+Concurrent calls share successful recovery. Replacing or signing out that session
+prevents replay under another identity. The call preserves its original payload values.
+A function's own response, HTTP 403, or a network failure never triggers this retry.
+Anonymous and service keys do not refresh.
 
 `logs.search()` returns an immutable page of retained runtime or deployment log
 events. Pass `next_cursor` back as `cursor` to continue a search. `logs.activity()`

volcano_sdk_python-0.9.3/features/staged/functions-refresh.feature

@@ -0,0 +1,10 @@
+Feature: SDK function authentication recovery
+
+  @functions @SDK-FUNCTIONS-002
+  Scenario: A rejected user credential refreshes before function dispatch
+    Given an authenticated client
+    And the client replaces its access token with a rejected token
+    When the authenticated client invokes the contract function by name
+    Then the SDK operation succeeds
+    And the function echoes the payload
+    And the function invocation replaces the rejected token for the same user

{volcano_sdk_python-0.9.2 → volcano_sdk_python-0.9.3}/features/steps/sdk_contract_steps.py

@@ -266,6 +266,7 @@ def replace_access_token(context: Any) -> None:
     )
 
 
+@then("the function invocation replaces the rejected token for the same user")
 @then("the session list replaces the rejected token for the same user")
 @then("the profile read replaces the rejected token for the same user")
 @then("the storage operation replaces the rejected token for the same user")
@@ -1104,6 +1105,16 @@ def subscriber_received_message(context: Any) -> None:
     assert world.last_outcome.value == world.realtime_message
 
 
+@when("the authenticated client invokes the contract function by name")
+def invoke_authenticated_contract_function(context: Any) -> None:
+    world = _world(context)
+    world.record(
+        lambda: world.client.functions.invoke(
+            world.fixture["function_name"], {"value": "contract"}
+        )
+    )
+
+
 @when("the client invokes the contract function by name")
 def invoke_contract_function(context: Any) -> None:
     world = _world(context)

{volcano_sdk_python-0.9.2 → volcano_sdk_python-0.9.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "volcano-sdk-python"
-version = "0.9.2"
+version = "0.9.3"
 description = "Official Python SDK for Volcano"
 readme = "README.md"
 requires-python = ">=3.11"

{volcano_sdk_python-0.9.2 → volcano_sdk_python-0.9.3}/src/volcano_sdk/_transport.py

@@ -99,10 +99,12 @@ from ._generated.api.database_queries.query_database_update import (
 from ._generated.api.database_queries.query_database_update import (
     _get_kwargs as database_update_kwargs,
 )
-from ._generated.api.functions import resolve_function_for_invocation
 from ._generated.api.functions.invoke_function import (
     _get_kwargs as invoke_function_kwargs,
 )
+from ._generated.api.functions.resolve_function_for_invocation import (
+    _get_kwargs as resolve_function_kwargs,
+)
 from ._generated.api.locks import (
     force_release_project_lock,
     get_project_lock,
@@ -1643,11 +1645,10 @@ class GeneratedTransport:
         name: str,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = resolve_function_for_invocation.sync_detailed(
-                client=client,
-                name=name,
+            response = client.get_httpx_client().request(
+                **resolve_function_kwargs(name=name)
             )
-        return self._response(response)
+        return self._raw_response(response)
 
     def invoke_function(
         self,

{volcano_sdk_python-0.9.2 → volcano_sdk_python-0.9.3}/src/volcano_sdk/functions.py

@@ -4,14 +4,19 @@ from __future__ import annotations
 
 import json
 import re
-from collections.abc import Mapping
-from typing import TYPE_CHECKING, Protocol, cast
+from collections.abc import Callable, Mapping
+from typing import TYPE_CHECKING, Protocol, TypeVar, cast
 
 from . import _function_resolution
 from ._function_resolution import FunctionResolution
 from ._transport import TransportResponse, invoke, response_payload
-from .errors import NotFoundError
-from .models import FunctionResponse, JSONValue
+from .errors import (
+    AuthenticationError,
+    NotFoundError,
+    SessionChangedError,
+    VolcanoError,
+)
+from .models import FunctionResponse, JSONValue, _freeze_json
 
 if TYPE_CHECKING:
     from .client import VolcanoClient
@@ -27,10 +32,57 @@ _UNKNOWN_FUNCTION = "Function was not found"
 _HTTP_SUCCESS_MIN = 200
 _HTTP_SUCCESS_MAX = 300
 _HTTP_NOT_FOUND = 404
+_HTTP_UNAUTHORIZED = 401
 # Present only once the platform has dispatched to the function.
 _FUNCTION_INVOKED_HEADER = "X-Volcano-Function-Invoked"
 
 
+_Result = TypeVar("_Result")
+
+
+class _FunctionAuth:
+    def __init__(self, client: VolcanoClient) -> None:
+        self._client = client
+        self._binding = client._capture_session_binding()
+        self._fallback_token = client._function_token()
+
+    def run(self, operation: Callable[[str], _Result]) -> _Result:
+        if self._binding[2] is not None:
+            self._binding = self._client.auth._owned_refresh_session(self._binding)
+        try:
+            return self._run(operation)
+        finally:
+            if self._binding[2] is not None:
+                self._client.auth._validate_read_failure(self._binding)
+            elif self._client._capture_session_binding()[1] != self._binding[1]:
+                raise SessionChangedError
+
+    def _run(self, operation: Callable[[str], _Result]) -> _Result:
+        try:
+            return operation(self._token())
+        except AuthenticationError as original:
+            if self._binding[2] is None or original.status != _HTTP_UNAUTHORIZED:
+                raise
+            try:
+                # Resolve has released its cache lock before refresh callbacks run.
+                self._client.auth._refresh_session_for_binding(self._binding)
+            except SessionChangedError:
+                raise
+            except VolcanoError:
+                raise original from None
+            return operation(self._token())
+
+    def _token(self) -> str:
+        if self._binding[2] is None:
+            if self._client._capture_session_binding()[1] != self._binding[1]:
+                raise SessionChangedError
+            return self._fallback_token
+        session = self._client.auth._owned_refresh_session(self._binding)[2]
+        if session is None:
+            raise SessionChangedError
+        return session.access_token
+
+
 class FunctionsTransport(Protocol):
     """Transport operations required by the functions facade."""
 
@@ -77,13 +129,17 @@ class Functions:
         payload: Mapping[str, JSONValue] | None = None,
     ) -> FunctionResponse:
         """Resolve and invoke a function with an optional JSON object payload."""
+        auth = _FunctionAuth(self._client)
         name = _function_name(name)
         request_payload = _function_payload(payload)
-        authorization = self._client._function_token()
         transport = cast("FunctionsTransport", self._client._transport)
-        resolution = self._resolve(transport, authorization, name)
-        response = self._invoke_resolved(
-            transport, authorization, resolution, request_payload
+        authorization, resolution = auth.run(
+            lambda token: (token, self._resolve(transport, token, name))
+        )
+        response = auth.run(
+            lambda token: self._invoke_resolved(
+                transport, token, resolution, request_payload
+            )
         )
         if _stale_mapping(response):
             # The function was deleted and recreated, so the cached identity no
@@ -91,9 +147,13 @@ class Functions:
             _function_resolution.forget(
                 self._client._api_base_url(), authorization, name
             )
-            resolution = self._resolve(transport, authorization, name)
-            response = self._invoke_resolved(
-                transport, authorization, resolution, request_payload
+            _, resolution = auth.run(
+                lambda token: (token, self._resolve(transport, token, name))
+            )
+            response = auth.run(
+                lambda token: self._invoke_resolved(
+                    transport, token, resolution, request_payload
+                )
             )
         return self._response(response)
 
@@ -118,7 +178,13 @@ class Functions:
                 invoke_url=resolution.invoke_url,
                 payload=payload,
             )
-        return cast("TransportResponse", response)
+        response = cast("TransportResponse", response)
+        if (
+            response.status_code == _HTTP_UNAUTHORIZED
+            and _header(response.headers, _FUNCTION_INVOKED_HEADER) is None
+        ):
+            response_payload(response, _HTTP_SUCCESS_MIN)
+        return response
 
     def _resolve(
         self,
@@ -269,9 +335,9 @@ def _function_name(value: object) -> str:
     return value
 
 
-def _function_payload(value: object) -> dict[str, JSONValue]:
+def _function_payload(value: object) -> Mapping[str, JSONValue]:
     if value is None:
         return {}
     if not isinstance(value, Mapping):
         raise TypeError(_INVALID_FUNCTION_PAYLOAD)
-    return dict(cast("Mapping[str, JSONValue]", value))
+    return cast("Mapping[str, JSONValue]", _freeze_json(cast("JSONValue", value)))

{volcano_sdk_python-0.9.2 → volcano_sdk_python-0.9.3}/tests/unit/test_contract_bindings.py

@@ -137,6 +137,8 @@ def test_every_contract_phrase_is_bound_verbatim() -> None:
         for definition in definitions
     }
     assert bound == {
+        "the authenticated client invokes the contract function by name",
+        "the function invocation replaces the rejected token for the same user",
         "the client selects a projected page of query fixture members",
         "the projected page contains only beta and gamma in that order",
         "the client selects query fixture rows with each comparison filter",

volcano_sdk_python-0.9.3/tests/unit/test_function_refresh.py

@@ -0,0 +1,328 @@
+from __future__ import annotations
+
+import json
+from concurrent.futures import ThreadPoolExecutor
+from threading import Barrier
+from typing import TYPE_CHECKING
+
+import httpx
+import pytest
+from session_fixtures import access_token
+
+from volcano_sdk import (
+    AuthenticationError,
+    Session,
+    SessionChangedError,
+    TransportError,
+    VolcanoClient,
+    VolcanoError,
+)
+from volcano_sdk._transport import GeneratedTransport
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from volcano_sdk.models import JSONValue
+
+USER_ID = "00000000-0000-4000-8000-000000000001"
+FUNCTION_ID = "00000000-0000-4000-8000-000000000040"
+
+
+def make_client(handler: Callable[[httpx.Request], httpx.Response]) -> VolcanoClient:
+    client = VolcanoClient(
+        anon_key="anon",
+        _transport=GeneratedTransport(
+            api_url="https://api.test.volcano.dev",
+            httpx_transport=httpx.MockTransport(handler),
+        ),
+    )
+    client.auth.set_session(Session(access_token("old"), "old-refresh", USER_ID))
+    return client
+
+
+def refreshed_response() -> httpx.Response:
+    return httpx.Response(
+        200,
+        json={
+            "access_token": access_token("new"),
+            "refresh_token": "new-refresh",
+            "token_type": "bearer",
+            "expires_in": 3600,
+            "user": {"id": USER_ID, "email": "user@example.com", "status": "active"},
+        },
+    )
+
+
+def resolved_response(invoke_url: str | None = None) -> httpx.Response:
+    return httpx.Response(
+        200,
+        json={
+            "name": "echo",
+            "function_id": FUNCTION_ID,
+            "cache_ttl_seconds": 60,
+            "invoke_url": invoke_url,
+        },
+    )
+
+
+@pytest.mark.parametrize("rejected_stage", ["resolve", "invoke"])
+@pytest.mark.parametrize(
+    "resolved_url", [None, "https://echo.functions.test.volcano.dev/invoke"]
+)
+def test_function_refreshes_rejected_stage_and_preserves_payload(
+    rejected_stage: str,
+    resolved_url: str | None,
+) -> None:
+    requests: list[httpx.Request] = []
+    values: list[JSONValue] = ["original"]
+    payload: dict[str, JSONValue] = {"values": values}
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        requests.append(request)
+        if request.url.path == "/auth/refresh":
+            values.append("changed")
+            return refreshed_response()
+        stage = "resolve" if request.url.path == "/functions/resolve" else "invoke"
+        if (
+            stage == rejected_stage
+            and request.headers["authorization"] == f"Bearer {access_token('old')}"
+        ):
+            return httpx.Response(401, json={"error": "expired", "code": "expired"})
+        return (
+            resolved_response(resolved_url)
+            if stage == "resolve"
+            else httpx.Response(200, json={"ok": True})
+        )
+
+    client = make_client(handle)
+    assert client.functions.invoke("echo", payload).data == {"ok": True}
+    assert sum(request.url.path == "/auth/refresh" for request in requests) == 1
+    invokes = [request for request in requests if request.url.path.endswith("/invoke")]
+    assert all(
+        json.loads(request.content) == {"payload": {"values": ["original"]}}
+        for request in invokes
+    )
+    assert invokes[-1].headers["authorization"] == f"Bearer {access_token('new')}"
+    assert client.current_session is not None
+    assert client.current_session.access_token == access_token("new")
+
+
+@pytest.mark.parametrize("status", [401, 403])
+def test_function_owned_authentication_error_never_replays(status: int) -> None:
+    requests: list[str] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        requests.append(request.url.path)
+        if request.url.path == "/functions/resolve":
+            return resolved_response()
+        return httpx.Response(
+            status,
+            json={"error": "application response"},
+            headers={"X-Volcano-Function-Invoked": "true"},
+        )
+
+    result = make_client(handle).functions.invoke("echo")
+    assert result.status == status
+    assert requests == ["/functions/resolve", f"/functions/{FUNCTION_ID}/invoke"]
+
+
+@pytest.mark.parametrize("stage", ["resolve", "invoke"])
+def test_function_rejects_replacement_session_before_return_or_dispatch(
+    stage: str,
+) -> None:
+    invokes: list[str] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        current = "resolve" if request.url.path == "/functions/resolve" else "invoke"
+        if current == stage:
+            client.auth.set_session(
+                Session(access_token("replacement"), "replacement-refresh", USER_ID)
+            )
+        if current == "invoke":
+            invokes.append(request.headers["authorization"])
+            return httpx.Response(200, json={"ok": True})
+        return resolved_response()
+
+    client = make_client(handle)
+    with pytest.raises(SessionChangedError):
+        client.functions.invoke("echo")
+    assert len(invokes) == (0 if stage == "resolve" else 1)
+    assert client.current_session is not None
+    assert client.current_session.refresh_token == "replacement-refresh"
+
+
+@pytest.mark.parametrize("refresh_status", [200, 401, 503])
+def test_function_bounds_retry_and_preserves_original_rejection(
+    refresh_status: int,
+) -> None:
+    requests: list[str] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        requests.append(request.url.path)
+        if request.url.path == "/auth/refresh":
+            return (
+                refreshed_response()
+                if refresh_status == 200
+                else httpx.Response(refresh_status, json={"error": "refresh failed"})
+            )
+        return httpx.Response(
+            401, json={"error": "original denial", "code": "original"}
+        )
+
+    with pytest.raises(AuthenticationError, match="original denial") as failure:
+        make_client(handle).functions.invoke("echo")
+    assert failure.value.status == 401
+    assert failure.value.code == "original"
+    assert requests.count("/auth/refresh") == 1
+    assert requests.count("/functions/resolve") == (2 if refresh_status == 200 else 1)
+
+
+@pytest.mark.parametrize("rejected_stage", ["resolve", "invoke"])
+def test_function_refreshes_a_malformed_platform_401(rejected_stage: str) -> None:
+    calls: list[str] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        calls.append(request.url.path)
+        if request.url.path == "/auth/refresh":
+            return refreshed_response()
+        stage = "resolve" if request.url.path == "/functions/resolve" else "invoke"
+        if (
+            stage == rejected_stage
+            and request.headers["authorization"] == f"Bearer {access_token('old')}"
+        ):
+            return httpx.Response(401, text="not JSON")
+        return (
+            resolved_response()
+            if stage == "resolve"
+            else httpx.Response(200, json={"ok": True})
+        )
+
+    assert make_client(handle).functions.invoke("echo").data == {"ok": True}
+    assert calls.count("/auth/refresh") == 1
+
+
+@pytest.mark.parametrize("stage", ["resolve", "invoke"])
+@pytest.mark.parametrize("failure", ["forbidden", "network"])
+def test_function_never_replays_forbidden_or_uncertain_requests(
+    stage: str, failure: str
+) -> None:
+    paths: list[str] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        paths.append(request.url.path)
+        current = "resolve" if request.url.path == "/functions/resolve" else "invoke"
+        if current == stage:
+            if failure == "network":
+                message = "connection lost"
+                raise httpx.ReadError(message)
+            return httpx.Response(403, json={"error": "forbidden"})
+        return resolved_response()
+
+    with pytest.raises(TransportError if failure == "network" else VolcanoError):
+        make_client(handle).functions.invoke("echo")
+    assert len(paths) == (1 if stage == "resolve" else 2)
+    assert "/auth/refresh" not in paths
+
+
+@pytest.mark.parametrize("key", ["anon", "service"])
+def test_function_does_not_refresh_key_credentials(key: str) -> None:
+    paths: list[str] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        paths.append(request.url.path)
+        assert request.headers["authorization"] == f"Bearer {key}"
+        return httpx.Response(401, json={"error": "invalid key"})
+
+    client = VolcanoClient(
+        anon_key="anon",
+        service_key=key if key == "service" else None,
+        _transport=GeneratedTransport(
+            api_url="https://api.test.volcano.dev",
+            httpx_transport=httpx.MockTransport(handle),
+        ),
+    )
+    with pytest.raises(AuthenticationError, match="invalid key"):
+        client.functions.invoke("echo")
+    assert paths == ["/functions/resolve"]
+
+
+@pytest.mark.parametrize("replace_at", ["refresh", "listener"])
+def test_function_does_not_dispatch_after_refresh_replaces_session(
+    replace_at: str,
+) -> None:
+    paths: list[str] = []
+    replacement = Session(access_token("replacement"), "replacement-refresh", USER_ID)
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        paths.append(request.url.path)
+        if request.url.path == "/auth/refresh":
+            if replace_at == "refresh":
+                client.auth.set_session(replacement)
+            return refreshed_response()
+        return httpx.Response(401, json={"error": "expired"})
+
+    client = make_client(handle)
+    if replace_at == "listener":
+
+        def replace(event: str, _session: Session | None) -> None:
+            if event == "TOKEN_REFRESHED":
+                client.auth.set_session(replacement)
+
+        client.auth.on_auth_state_change(replace)
+    with pytest.raises(SessionChangedError):
+        client.functions.invoke("echo")
+    assert paths == ["/functions/resolve", "/auth/refresh"]
+    assert client.current_session == replacement
+
+
+@pytest.mark.parametrize("refresh_status", [200, 401])
+def test_concurrent_function_invocations_share_refresh(refresh_status: int) -> None:
+    initial_calls = Barrier(2, timeout=5)
+    refreshes: list[httpx.Request] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        if request.url.path == "/auth/refresh":
+            refreshes.append(request)
+            return (
+                refreshed_response()
+                if refresh_status == 200
+                else httpx.Response(401, json={"error": "refresh rejected"})
+            )
+        if request.url.path == "/functions/resolve":
+            return resolved_response()
+        if request.headers["authorization"] == f"Bearer {access_token('old')}":
+            initial_calls.wait()
+            return httpx.Response(401, json={"error": "invocation rejected"})
+        return httpx.Response(200, json={"ok": True})
+
+    client = make_client(handle)
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        calls = [pool.submit(client.functions.invoke, "echo") for _ in range(2)]
+        for call in calls:
+            if refresh_status == 200:
+                assert call.result(timeout=5).data == {"ok": True}
+            else:
+                with pytest.raises(AuthenticationError, match="invocation rejected"):
+                    call.result(timeout=5)
+    assert len(refreshes) == 1
+
+
+def test_function_refreshes_the_token_captured_at_each_rejected_stage() -> None:
+    refreshes: list[str] = []
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        if request.url.path == "/auth/refresh":
+            refreshes.append(request.url.path)
+            result = refreshed_response().json()
+            result["access_token"] = access_token(f"renewed-{len(refreshes)}")
+            result["refresh_token"] = f"refresh-{len(refreshes)}"
+            return httpx.Response(200, json=result)
+        if request.url.path == "/functions/resolve":
+            if request.headers["authorization"] != f"Bearer {access_token('old')}":
+                return resolved_response()
+        elif request.headers["authorization"] == f"Bearer {access_token('renewed-2')}":
+            return httpx.Response(200, json={"ok": True})
+        return httpx.Response(401, json={"error": "stage expired"})
+
+    assert make_client(handle).functions.invoke("echo").data == {"ok": True}
+    assert len(refreshes) == 2

{volcano_sdk_python-0.9.2 → volcano_sdk_python-0.9.3}/uv.lock

@@ -918,7 +918,7 @@ wheels = [
 
 [[package]]
 name = "volcano-sdk-python"
-version = "0.9.2"
+version = "0.9.3"
 source = { editable = "." }
 dependencies = [
     { name = "attrs" },

volcano_sdk_python-0.9.2/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.9.2"
-}