marimo-export 0.0.3__tar.gz → 0.0.4__tar.gz

{marimo_export-0.0.3 → marimo_export-0.0.4}/.agent-plugin/skills/notebook-to-static-app/scripts/scaffold_app.py

@@ -380,7 +380,7 @@ def _write_package_json(
             "vite-plus": "0.3.0",
         },
         "engines": {"node": ">=22.18.0"},
-        "packageManager": "pnpm@11.25.0",
+        "packageManager": "pnpm@12.3.4",
     }
     path.write_text(json.dumps(value, indent=2) + "\n", encoding="utf-8")
 

{marimo_export-0.0.3 → marimo_export-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marimo-export
-Version: 0.0.3
+Version: 0.0.4
 Summary: Prepare and read verified exports of selected marimo notebook outputs.
 Keywords: cache,export,marimo,notebook
 Author: marimo team

{marimo_export-0.0.3 → marimo_export-0.0.4}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "agent_plugins.build.uv_build"
 
 [project]
 name = "marimo-export"
-version = "0.0.3"
+version = "0.0.4"
 description = "Prepare and read verified exports of selected marimo notebook outputs."
 readme = "README.md"
 license = "Apache-2.0"

{marimo_export-0.0.3 → marimo_export-0.0.4}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "agent_plugins.build.uv_build"
 
 [project]
 name = "marimo-export"
-version = "0.0.3"
+version = "0.0.4"
 description = "Prepare and read verified exports of selected marimo notebook outputs."
 readme = "README.md"
 license = "Apache-2.0"

marimo_export-0.0.3/src/marimo_export/_services/identity.py → marimo_export-0.0.4/src/marimo_export/_environment.py

@@ -1,4 +1,4 @@
-"""Compute export producer identity without starting a notebook process."""
+"""Fingerprint installed distributions and local runtime dependencies."""
 
 from __future__ import annotations
 
@@ -7,185 +7,18 @@ import hashlib
 import importlib.metadata
 import importlib.util
 import os
-import platform
-import stat
 import sys
-from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from marimo_export._format import digest
-from marimo_export._identity import require_implementation_stable
 from marimo_export._json import JsonObject, canonical_bytes, sha256_bytes
-from marimo_export._notebook import _notebook_path, _read_stable_source, document_sha256
-from marimo_export._portable import validate_portable_basename
-from marimo_export.errors import CompatibilityError, ExecutionError
-from marimo_export.index import ProducerProvenance
-from marimo_export.spec import StrPath
 
 
-@dataclass(frozen=True, slots=True)
-class ProducerIdentity:
-    """Stable producer facts used for repository reuse and export provenance."""
+def environment_identity(source: Path | None, *, exclude_source: bool = False) -> str:
+    """Hash stable runtime dependencies, optionally leaving notebook code to Marimo."""
 
-    source: Path | None
-    filename: str | None
-    source_sha256: str
-    document_sha256: str
-    producer_sha256: str
-    marimo_version: str
-    marimo_export_version: str
-    implementation_sha256: str
-    environment_sha256: str
-
-    def __post_init__(self) -> None:
-        if self.source is not None:
-            if not isinstance(self.source, Path) or not self.source.is_absolute():
-                raise ValueError("producer source must be an absolute pathlib.Path or None")
-            try:
-                metadata = self.source.lstat()
-            except OSError as error:
-                raise ValueError("producer source must be available") from error
-            if not stat.S_ISREG(metadata.st_mode):
-                raise ValueError("producer source must be a regular file")
-            if self.filename != self.source.name:
-                raise ValueError("producer filename must match its source basename")
-        if self.filename is not None:
-            validate_portable_basename(self.filename, "producer filename")
-        for name in (
-            "source_sha256",
-            "document_sha256",
-            "producer_sha256",
-            "implementation_sha256",
-            "environment_sha256",
-        ):
-            digest(getattr(self, name), f"producer {name}")
-        for name in ("marimo_version", "marimo_export_version"):
-            value = getattr(self, name)
-            if (
-                not isinstance(value, str)
-                or not value
-                or len(value.encode("utf-8")) > 255
-                or any(ord(character) < 32 or ord(character) == 127 for character in value)
-            ):
-                raise ValueError(f"producer {name} must be a bounded nonempty string")
-
-    @property
-    def provenance(self) -> ProducerProvenance:
-        return ProducerProvenance(
-            marimo=self.marimo_version,
-            marimo_export=self.marimo_export_version,
-            implementation_sha256=self.implementation_sha256,
-        )
-
-
-def producer_identity(source: StrPath) -> ProducerIdentity:
-    """Return exact source and runtime identity without executing notebook code."""
-
-    notebook = _notebook_path(source)
-    _, source_sha256, source_revision = _read_stable_source(notebook)
-    document = document_sha256(notebook)
-    _, after_sha256, after_revision = _read_stable_source(notebook)
-    if after_sha256 != source_sha256 or after_revision != source_revision:
-        raise RuntimeError("notebook source changed while producer identity was computed")
-
-    return _identity_from_facts(
-        document_sha256=document,
-        source_sha256=source_sha256,
-        source=notebook,
-        filename=notebook.name,
-    )
-
-
-def runtime_producer_identity(
-    *,
-    document_sha256: str,
-    source: StrPath | None = None,
-    source_sha256: str | None = None,
-    filename: str | None = None,
-) -> ProducerIdentity:
-    """Return producer identity from runtime facts available inside a kernel."""
-
-    if source is not None:
-        stable = producer_identity(source)
-        if stable.document_sha256 != document_sha256:
-            raise ExecutionError(
-                "the runtime source does not match the inspected notebook document",
-                code="parent_document_changed",
-                details={
-                    "expected": document_sha256,
-                    "actual": stable.document_sha256,
-                },
-            )
-        return stable
-    return _identity_from_facts(
-        document_sha256=document_sha256,
-        source_sha256=document_sha256 if source_sha256 is None else source_sha256,
-        source=None,
-        filename=filename,
-    )
-
-
-def _identity_from_facts(
-    *,
-    document_sha256: str,
-    source_sha256: str,
-    source: Path | None,
-    filename: str | None,
-) -> ProducerIdentity:
-    marimo_version = _required_distribution_version("marimo")
-    export_version = _distribution_version("marimo-export", fallback="0.0.0")
-    implementation = require_implementation_stable()
-    environment = _environment_identity(source)
-    producer = sha256_bytes(
-        canonical_bytes(
-            {
-                "document_sha256": document_sha256,
-                "environment_sha256": environment,
-                "implementation_sha256": implementation,
-                "marimo": marimo_version,
-                "marimo_export": export_version,
-                "platform": {
-                    "machine": platform.machine(),
-                    "system": platform.system(),
-                },
-                "python": {
-                    "abi": sys.implementation.cache_tag or "unknown",
-                    "implementation": sys.implementation.name,
-                    "version": platform.python_version(),
-                },
-                "source_sha256": source_sha256,
-            }
-        )
-    )
-    return ProducerIdentity(
-        source=source,
-        filename=filename,
-        source_sha256=source_sha256,
-        document_sha256=document_sha256,
-        producer_sha256=producer,
-        marimo_version=marimo_version,
-        marimo_export_version=export_version,
-        implementation_sha256=implementation,
-        environment_sha256=environment,
-    )
-
-
-def producer_sha256(source: StrPath) -> str:
-    """Return the spec-independent producer identity for one notebook source."""
-
-    return producer_identity(source).producer_sha256
-
-
-def managed_runtime_source(runtime_path: str | None) -> str | None:
-    """Return the authored source path selected for an attached runtime."""
-
-    return os.environ.get("MARIMO_EXPORT_MANAGED_SOURCE") or runtime_path
-
-
-def _environment_identity(source: Path | None) -> str:
     distributions = _installed_distributions()
-    sources = {} if source is None else _local_source_record(source)
+    sources = {} if source is None else _local_source_record(source, exclude_source=exclude_source)
     if _installed_distributions() != distributions:
         raise RuntimeError("installed distributions changed while identity was computed")
     return sha256_bytes(
@@ -214,16 +47,20 @@ def _installed_distributions() -> list[JsonObject]:
     return distributions
 
 
-def _local_source_record(source: Path) -> JsonObject:
+def _local_source_record(source: Path, *, exclude_source: bool = False) -> JsonObject:
     try:
         resolved = source.resolve(strict=True)
         root, search_roots = _local_source_roots(resolved)
         before = _local_source_manifest(root, search_roots)
+        if exclude_source:
+            before = tuple(row for row in before if root / row[0] != resolved)
         records: JsonObject = {}
         for relative, *_revision_parts in before:
             records[relative] = _stable_file_sha256(root / relative)
         after_root, after_search_roots = _local_source_roots(resolved)
         after = _local_source_manifest(root, search_roots)
+        if exclude_source:
+            after = tuple(row for row in after if root / row[0] != resolved)
         after_records = {
             relative: _stable_file_sha256(root / relative) for relative, *_revision_parts in after
         }
@@ -249,7 +86,7 @@ def _local_source_manifest(
     paths: set[Path] = set()
     for search_root in selected:
         if search_root.is_file():
-            if _source_file(search_root) and not _excluded_source(search_root, root):
+            if _source_file(search_root) and not _excluded_source(search_root, search_root.parent):
                 paths.add(search_root)
             continue
         if not search_root.is_dir() or search_root.is_symlink():
@@ -259,12 +96,12 @@ def _local_source_manifest(
             directories[:] = [
                 name
                 for name in sorted(directories)
-                if not _excluded_source(current_path / name, root)
+                if not _excluded_source(current_path / name, search_root)
                 and not (current_path / name).is_symlink()
             ]
             for name in sorted(filenames):
                 path = current_path / name
-                if _source_file(path) and not _excluded_source(path, root):
+                if _source_file(path) and not _excluded_source(path, search_root):
                     paths.add(path)
     return tuple(
         (
@@ -301,7 +138,12 @@ def _local_source_roots(source: Path) -> tuple[Path, tuple[Path, ...]]:
         if not base.is_dir() or base.is_symlink():
             continue
         for child in base.iterdir():
-            if child.is_dir() and not child.is_symlink() and (child / "__init__.py").is_file():
+            if (
+                child.is_dir()
+                and not child.is_symlink()
+                and not _excluded_source(child, base)
+                and (child / "__init__.py").is_file()
+            ):
                 roots.add(child)
         for name in names:
             module = base / f"{name}.py"
@@ -400,27 +242,4 @@ def _revision(value: Any) -> tuple[int, int, int, int, int]:
     )
 
 
-def _required_distribution_version(name: str) -> str:
-    try:
-        return importlib.metadata.version(name)
-    except importlib.metadata.PackageNotFoundError as error:
-        raise CompatibilityError(
-            f"required runtime distribution {name!r} is unavailable",
-            code="runtime_distribution_unavailable",
-        ) from error
-
-
-def _distribution_version(name: str, *, fallback: str) -> str:
-    try:
-        return importlib.metadata.version(name)
-    except importlib.metadata.PackageNotFoundError:
-        return fallback
-
-
-__all__ = [
-    "ProducerIdentity",
-    "managed_runtime_source",
-    "producer_identity",
-    "producer_sha256",
-    "runtime_producer_identity",
-]
+__all__ = ["environment_identity"]

{marimo_export-0.0.3 → marimo_export-0.0.4}/src/marimo_export/_marimo/compat/cache/attempts.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import ast
+import copy
 import threading
 from collections.abc import Callable, Iterator
 from contextlib import contextmanager
@@ -54,6 +56,7 @@ class _GraphScope:
     graph: Any
     output_cells: frozenset[Any]
     activity: CacheAttemptLog
+    environment: str | None = None
     forced_cells: frozenset[Any] = frozenset()
 
 
@@ -65,6 +68,8 @@ _SCOPES: dict[int, _GraphScope] = {}
 def track_notebook_cache(
     child_graph: Any,
     output_cell_ids: frozenset[Any],
+    *,
+    environment: str | None = None,
 ) -> Iterator[CacheAttemptLog]:
     """Record effective cache decisions for one exact child graph."""
 
@@ -72,6 +77,7 @@ def track_notebook_cache(
         graph=child_graph,
         output_cells=output_cell_ids,
         activity=CacheAttemptLog(),
+        environment=environment,
     )
     key = id(child_graph)
     with _SCOPES_LOCK:
@@ -88,10 +94,10 @@ def track_notebook_cache(
 
 
 @contextmanager
-def track_managed_parent_cache(graph: Any) -> Iterator[None]:
+def track_managed_parent_cache(graph: Any, *, environment: str | None = None) -> Iterator[None]:
     """Activate export cache policy for one owned parent graph."""
 
-    with track_notebook_cache(graph, frozenset()):
+    with track_notebook_cache(graph, frozenset(), environment=environment):
         yield
 
 
@@ -124,6 +130,11 @@ def cache_attempt_wrapper(native: Callable[..., Cache]) -> Callable[..., Cache]:
         *args: Any,
         **kwargs: Any,
     ) -> Cache:
+        with _SCOPES_LOCK:
+            scope = _SCOPES.get(id(graph))
+            environment = scope.environment if scope is not None and scope.graph is graph else None
+        if environment is not None:
+            module, scope_values = _with_environment(module, scope_values, environment)
         attempt = native(
             module,
             graph,
@@ -160,6 +171,42 @@ def cache_attempt_wrapper(native: Callable[..., Cache]) -> Callable[..., Cache]:
     return tracked
 
 
+def _with_environment(
+    module: ast.Module,
+    scope: dict[str, Any],
+    environment: str,
+) -> tuple[ast.Module, dict[str, Any]]:
+    from marimo._ast.transformers import DeprivateVisitor
+    from marimo._ast.variables import unmangle_local
+    from marimo._ast.visitor import ScopedVisitor
+
+    lookup = DeprivateVisitor().visit(copy.deepcopy(module))
+    visitor = ScopedVisitor("", ignore_local=True)
+    visitor.visit(lookup)
+    names = visitor.defs | visitor.refs | {unmangle_local(name).name for name in scope}
+    name = "__marimo_export_cache_environment"
+    while name in scope or name in names:
+        name += "_"
+    reference = ast.Expr(value=ast.Name(id=name, ctx=ast.Load()))
+    # The native hasher receives this reference. Authored execution keeps its
+    # original AST and scope, so the dependency input creates no notebook name.
+    lookup.body.append(reference)
+    return ast.fix_missing_locations(lookup), {**scope, name: environment}
+
+
+def record_cache_miss(graph: Any, cell_id: Any) -> None:
+    """Record a live run chosen after native restoration."""
+
+    with _SCOPES_LOCK:
+        scope = _scope_for(graph)
+        target = (
+            scope.activity.output_cells
+            if cell_id in scope.output_cells
+            else scope.activity.authored_cells
+        )
+        target[cell_id] = "miss"
+
+
 def _scope_for(graph: Any) -> _GraphScope:
     scope = _SCOPES.get(id(graph))
     if scope is None or scope.graph is not graph:
@@ -175,6 +222,14 @@ def has_cache_scope(graph: Any) -> bool:
         return scope is not None and scope.graph is graph
 
 
+def tracked_environment(graph: Any) -> str | None:
+    """Return the dependency identity frozen by this graph's owner."""
+
+    with _SCOPES_LOCK:
+        scope = _SCOPES.get(id(graph))
+        return scope.environment if scope is not None and scope.graph is graph else None
+
+
 def _rerun_unavailable_attempt(attempt: Cache) -> Cache:
     if not attempt.hit or not (
         any(_contains_unavailable(value) for value in attempt.defs.values())
@@ -213,6 +268,8 @@ __all__ = [
     "cache_attempt_wrapper",
     "force_cache_misses",
     "has_cache_scope",
+    "record_cache_miss",
     "track_managed_parent_cache",
     "track_notebook_cache",
+    "tracked_environment",
 ]

{marimo_export-0.0.3 → marimo_export-0.0.4}/src/marimo_export/_marimo/compat/cache/lifecycle.py

@@ -12,6 +12,7 @@ from marimo_export._marimo.compat.cache.attempts import (
     _empty_attempt,
     _rerun_unavailable_attempt,
     has_cache_scope,
+    record_cache_miss,
 )
 
 
@@ -23,6 +24,7 @@ class CompleteCachedLifecycle(CachedLifecycle):
         if not has_cache_scope(self._graph):
             return decision
         if not isinstance(decision, Skip):
+            record_cache_miss(self._graph, cell.cell_id)
             return decision
         attempt = self._attempts.get(cell.cell_id)
         if attempt is None:
@@ -36,6 +38,7 @@ class CompleteCachedLifecycle(CachedLifecycle):
             return decision
         self._attempts[cell.cell_id] = retry
         self._exec_starts[cell.cell_id] = time.time()
+        record_cache_miss(self._graph, cell.cell_id)
         return None
 
 

{marimo_export-0.0.3 → marimo_export-0.0.4}/src/marimo_export/_marimo/compat/cache/patch.py

@@ -179,13 +179,22 @@ async def sequential_cache_loader() -> AsyncIterator[None]:
 
 
 @contextmanager
-def managed_cache_compat(hooks: Any, parent_graph: Any | None = None) -> Iterator[None]:
+def managed_cache_compat(
+    hooks: Any,
+    parent_graph: Any | None = None,
+    *,
+    environment: str | None = None,
+) -> Iterator[None]:
     """Install cache behavior for one owned kernel lifespan."""
 
     from marimo_export._marimo.compat.cache.attempts import track_managed_parent_cache
     from marimo_export._marimo.compat.cache.barrier import add_cache_write_barrier
 
-    scope = nullcontext() if parent_graph is None else track_managed_parent_cache(parent_graph)
+    scope = (
+        nullcontext()
+        if parent_graph is None
+        else track_managed_parent_cache(parent_graph, environment=environment)
+    )
     with scope:
         handle = _PATCHES.open()
         try:

{marimo_export-0.0.3 → marimo_export-0.0.4}/src/marimo_export/_marimo/compat/cache/probe.py

@@ -49,6 +49,7 @@ def require_cache_capabilities() -> None:
 
     try:
         import marimo._runtime.context as context_module
+        import marimo._save.hash as hash_module
         import marimo._save.loaders as loaders_module
         import marimo._save.loaders.lazy as lazy_module
         import marimo._save.stubs as stubs_module
@@ -71,6 +72,7 @@ def require_cache_capabilities() -> None:
     blob_schema = getattr(stubs_module, "BlobAsset", None)
 
     symbols = {
+        "BlockHasher": getattr(hash_module, "BlockHasher", None),
         "CachedLifecycle.__init__": getattr(lifecycle, "__init__", None),
         "CachedLifecycle._restored_ui_defs": restored_ui_defs,
         "CachedLifecycle.setup": getattr(lifecycle, "setup", None),

{marimo_export-0.0.3 → marimo_export-0.0.4}/src/marimo_export/_marimo/compat/execution.py

@@ -7,9 +7,11 @@ import time
 from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
 from dataclasses import dataclass
+from pathlib import Path
 from types import MappingProxyType
 from typing import Any
 
+from marimo_export._environment import environment_identity
 from marimo_export._execution.plan import ExecutionPlan, NormalizedState, PlannedOutput
 from marimo_export._json import (
     JsonObject,
@@ -21,6 +23,7 @@ from marimo_export._marimo.compat.cache.attempts import (
     CacheAttemptLog,
     force_cache_misses,
     track_notebook_cache,
+    tracked_environment,
 )
 from marimo_export._marimo.compat.child_run import (
     StateChild,
@@ -94,9 +97,16 @@ async def execute_state(
                 state=state,
                 plan=plan,
             )
+            environment = tracked_environment(state_child.context.parent.graph)
+            if environment is None:
+                source = state_child.context.filename
+                environment = environment_identity(
+                    None if source is None else Path(source), exclude_source=True
+                )
             with track_notebook_cache(
                 state_child.runner._kernel.graph,
                 run_plan.transient_cache_cells,
+                environment=environment,
             ) as notebook_cache:
                 input_phase = await _execute_inputs(state_child, state, run_plan)
                 output_phase = await _execute_outputs(

{marimo_export-0.0.3 → marimo_export-0.0.4}/src/marimo_export/_marimo/compat/managed_kernel.py

@@ -5,6 +5,9 @@ from __future__ import annotations
 import os
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
+from pathlib import Path
+
+from marimo_export._environment import environment_identity
 
 _MANAGED_CACHE_COMPAT_ENV = "MARIMO_EXPORT_MANAGED_CACHE_COMPAT"
 _MANAGED_CACHE_ACTIVATION_ENV = "MARIMO_EXPORT_MANAGED_CACHE_ACTIVATION"
@@ -39,14 +42,13 @@ async def kernel_lifespan(_: None) -> AsyncIterator[None]:
     from marimo_export._marimo.compat.inspection import install_parent_stop_provenance
 
     context = get_context()
-    if not isinstance(context, KernelRuntimeContext):
+    if not isinstance(context, KernelRuntimeContext) or context.filename is None:
         raise RuntimeError("managed cache integration requires a file-backed marimo kernel")
     require_cache_capabilities()
+    environment = environment_identity(Path(context.filename), exclude_source=True)
     release_stop_provenance = install_parent_stop_provenance(context)
     try:
-        with managed_cache_compat(context._kernel._hooks, context.graph):
-            from pathlib import Path
-
+        with managed_cache_compat(context._kernel._hooks, context.graph, environment=environment):
             Path(activation_path).write_text(activation_token, encoding="utf-8")
             yield
     finally:

{marimo_export-0.0.3 → marimo_export-0.0.4}/src/marimo_export/_marimo/compat/release.json

@@ -2,12 +2,13 @@
   "version": "0.24.0",
   "commit": "854f7f2910b4bb4b6aebe650efc1f83ad40d9bef",
   "cache_source_sha256": {
-    "CachedLifecycle.__init__": "b68aab07eac87ce3e1d1dfb4aaf586cc4903e7e962b86aa6f05f369b487d5650",
-    "CachedLifecycle._restored_ui_defs": "4f1d2220a6d7e78d208d76fd4e08b4ab4ddb8da724e9725260e0264bf7cd77fc",
-    "CachedLifecycle.setup": "90d8e2a30661c728df5c4e40370e1224c61dc26de08f2e72bb273179e85ebfcc",
     "BlobAsset.schema_source": "ade24b0b25f4816aa296c3eda6623960f4a77c514c9124b5b6394f0c1ef3818a",
+    "BlockHasher": "c0b088d5c51322419fc3dbc8a0ed0bf715348300c4568b0eecaf25b5eb2e6ce1",
     "Cache.schema_source": "c587eb7298afd67887d9cb0c75d9f81e16d54c9f0c6b819d673ecbba35df8119",
     "CacheSignatureError": "ee0427f2e16982e20dad8ee34ea25b7ddb53ff545b2478ba36ab087c27e7280a",
+    "CachedLifecycle.__init__": "b68aab07eac87ce3e1d1dfb4aaf586cc4903e7e962b86aa6f05f369b487d5650",
+    "CachedLifecycle._restored_ui_defs": "4f1d2220a6d7e78d208d76fd4e08b4ab4ddb8da724e9725260e0264bf7cd77fc",
+    "CachedLifecycle.setup": "90d8e2a30661c728df5c4e40370e1224c61dc26de08f2e72bb273179e85ebfcc",
     "Item.schema_source": "4b7f1722b2d1583d1c905540a3be691d6bca1e5014d8227a48cf245e733f7062",
     "LazyLoader._effective_mode": "0e5efc063f8cf83a3b324f539fe3ed0eead25294cea12e5f1f11734b199bd3bb",
     "LazyLoader._read_blobs": "c0c69d24de338c5ab61669fa8b570e623944c60a014176d98c62df2c0af2f97f",
@@ -16,8 +17,8 @@
     "_verify_signed_blob": "8d650a60e10b9b36b3e312843fc1642e8b67c0b020c30f1afef6fa097473dd50",
     "cache_attempt_from_hash": "4a1b9421f70703337b2b0874997de0a3022dec99c3a7ed15b140c0e4ccb4f576",
     "encode._contiguous_tensor_bytes": "b5af49d65687b2ee6b1469ebe46299cb0f975d2f3135962108cbe1b7255f4642",
-    "from_item": "7a14447ebb9f4a8957580fe3eb16ec2108aefb7f086ae739d020de8a4f3ae7c8",
-    "flush_active_caches": "43a9a8956d21ab9adea51be5daaae66db07e17572dd7d138a53ef9695abe3a7c"
+    "flush_active_caches": "43a9a8956d21ab9adea51be5daaae66db07e17572dd7d138a53ef9695abe3a7c",
+    "from_item": "7a14447ebb9f4a8957580fe3eb16ec2108aefb7f086ae739d020de8a4f3ae7c8"
   },
   "receipt_schema_fields": {
     "BlobAsset": ["data", "media_type", "filename", "metadata"],

{marimo_export-0.0.3 → marimo_export-0.0.4}/src/marimo_export/_publication.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import math
 import threading
 from collections.abc import Callable, Hashable
 from dataclasses import dataclass, field
@@ -54,8 +55,12 @@ class PublicationControllerState(Generic[KeyT, MetadataT]):
         route_key: Callable[[KeyT], Hashable] | None,
         route_grace_seconds: float,
     ) -> None:
-        if route_grace_seconds < 0:
-            raise ValueError("route_grace_seconds must be nonnegative")
+        if isinstance(route_grace_seconds, bool) or not isinstance(
+            route_grace_seconds, (int, float)
+        ):
+            raise TypeError("route_grace_seconds must be a number")
+        if not math.isfinite(route_grace_seconds) or route_grace_seconds < 0:
+            raise ValueError("route_grace_seconds must be a finite nonnegative number")
         self._repository_value = repository
         self._owns_repository = repository is None
         self._repository_lock = threading.Lock()
@@ -118,7 +123,9 @@ class PublicationControllerState(Generic[KeyT, MetadataT]):
             return None
         pending = any(work.group == owned.group for work in self._work.values())
         if key not in self._refresh_tasks and not pending:
-            task = asyncio.create_task(self._refresh_if_stale(owned))
+            task = asyncio.create_task(
+                self._refresh_if_stale(owned, self._desired.get(owned.group))
+            )
             self._refresh_tasks[key] = task
             task.add_done_callback(
                 lambda completed, selected_key=key: self._refresh_finished(selected_key, completed)
@@ -202,9 +209,7 @@ class PublicationControllerState(Generic[KeyT, MetadataT]):
         work: _Work[KeyT, MetadataT],
     ) -> PreparedPublication[KeyT, MetadataT]:
         candidate = await asyncio.to_thread(
-            work.prepare,
-            self._repository(),
-            work.cancelled.is_set,
+            lambda: work.prepare(self._repository(), work.cancelled.is_set)
         )
         if not isinstance(candidate, PreparedPublicationCandidate):
             raise TypeError("prepare must return a PreparedPublicationCandidate")
@@ -245,6 +250,7 @@ class PublicationControllerState(Generic[KeyT, MetadataT]):
     async def _refresh_if_stale(
         self,
         selected: _OwnedPublication[KeyT, MetadataT],
+        desired: int | None,
     ) -> None:
         try:
             revision = await asyncio.to_thread(
@@ -254,6 +260,7 @@ class PublicationControllerState(Generic[KeyT, MetadataT]):
             if (
                 self._closed
                 or self._current.get(selected.key) is not selected
+                or self._desired.get(selected.group) != desired
                 or revision <= selected.publication.plan.observation_revision
             ):
                 return