flexcompute-core 0.0.1.dev0__tar.gz → 0.0.1.dev2__tar.gz

flexcompute_core-0.0.1.dev2/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.2
+Name: flexcompute-core
+Version: 0.0.1.dev2
+Summary: Shared internal modules for Flexcompute Python packages.
+Author-Email: "Flexcompute Inc." <support@flexcompute.com>
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3,>=2.10.3
+Requires-Dist: tomlkit<0.16.0,>=0.13.2
+Requires-Dist: autograd<2.0.0,>=1.7.0
+Requires-Dist: boto3<2.0.0,>=1.28.0
+Requires-Dist: click<9.0.0,>=8.1.0
+Requires-Dist: cryptography==48.0.1; platform_system == "Darwin" and platform_machine == "x86_64"
+Requires-Dist: cryptography!=48.0.1,>=44.0.0; platform_system != "Darwin" or platform_machine != "x86_64"
+Requires-Dist: dask<2027.0.0,>=2025.12.0
+Requires-Dist: fastmcp<4,>=3.4.4
+Requires-Dist: filelock<4.0.0,>=3.20.1
+Requires-Dist: h5netcdf<2.0.0,>=1.0.2
+Requires-Dist: h5py<3.17,>=3.0.0; python_version < "3.14"
+Requires-Dist: h5py<3.17,>=3.16.0; python_version >= "3.14"
+Requires-Dist: importlib-metadata<10.0.0,>=6.0.0
+Requires-Dist: joblib<2.0.0,>=1.5.3
+Requires-Dist: matplotlib<4.0.0,>=3.10.0
+Requires-Dist: numpy<2.5.0,>=2.2.6
+Requires-Dist: pandas<4.0,>=2.2
+Requires-Dist: pydantic-settings<3.0.0,>=2.10.0
+Requires-Dist: pyjwt<3.0.0,>=2.10.1
+Requires-Dist: pyroots<0.6.0,>=0.5.0
+Requires-Dist: PyYAML<7.0.0,>=6.0.3
+Requires-Dist: requests<3.0.0,>=2.31.0
+Requires-Dist: responses<0.27.0,>=0.25.8
+Requires-Dist: rich<16.0,>=13.0
+Requires-Dist: scipy!=1.15.0,!=1.15.1,!=1.15.2,<2.0,>=1.14
+Requires-Dist: shapely<3.0,>=2.1.0
+Requires-Dist: toml<0.11.0,>=0.10.2
+Requires-Dist: typing-extensions<5.0.0,>=4.15.0
+Requires-Dist: xarray<2026.8.0,>=2023.08
+Description-Content-Type: text/markdown
+
+# flexcompute-core
+
+> Internal package — not intended for public-facing usage.
+
+`flexcompute-core` contains shared internal modules used across Flexcompute's
+Python packages under the `flexcompute.core` namespace.
+
+The EM schema, preprocessing, and numerical modules migrated from the retired
+standalone EM distribution are staged under `flexcompute.core._migration.em`.
+That namespace is a temporary home for the moved code and is not a stable API;
+the modules move to their final `flexcompute.core` locations in follow-up changes.
+
+See the package [documentation](docs/configuration.md) for the configuration
+engine's responsibilities and development checks.
+
+It is not a standalone product, public client, or supported dependency for
+external applications. Product APIs and user-facing capabilities live in the
+owning product package.
+
+See [Flexcompute](https://www.flexcompute.com/) for product capabilities and
+the public [documentation](https://www.flexcompute.com/support/documentation/).

flexcompute_core-0.0.1.dev0/PKG-INFO → flexcompute_core-0.0.1.dev2/README.md

@@ -1,11 +1,3 @@
-Metadata-Version: 2.2
-Name: flexcompute-core
-Version: 0.0.1.dev0
-Summary: Shared internal modules for Flexcompute Python packages.
-Author-Email: "Flexcompute Inc." <support@flexcompute.com>
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-
 # flexcompute-core
 
 > Internal package — not intended for public-facing usage.
@@ -13,6 +5,14 @@ Description-Content-Type: text/markdown
 `flexcompute-core` contains shared internal modules used across Flexcompute's
 Python packages under the `flexcompute.core` namespace.
 
+The EM schema, preprocessing, and numerical modules migrated from the retired
+standalone EM distribution are staged under `flexcompute.core._migration.em`.
+That namespace is a temporary home for the moved code and is not a stable API;
+the modules move to their final `flexcompute.core` locations in follow-up changes.
+
+See the package [documentation](docs/configuration.md) for the configuration
+engine's responsibilities and development checks.
+
 It is not a standalone product, public client, or supported dependency for
 external applications. Product APIs and user-facing capabilities live in the
 owning product package.

flexcompute_core-0.0.1.dev2/docs/configuration.md

@@ -0,0 +1,29 @@
+# Configuration engine
+
+`flexcompute.core.config` provides product-neutral configuration mechanics:
+profile layering, Pydantic section validation, TOML persistence, atomic writes,
+schema migration execution, scoped runtime overrides, and per-section handlers.
+
+Products retain ownership of their public facades, section schemas, defaults,
+profile names, environment aliases, migration definitions, handlers, CLI
+commands, authentication validation, and endpoint catalogs. Core does not
+import product packages or product policy. Core tests the generic migration
+mechanism; products test their concrete migrations on their own surfaces.
+
+## Profile versioning
+
+`ConfigApp.version_profile_files` controls whether profile files include a
+`config_version` key and whether migrated profile files are written back to
+disk. Profile payloads still pass through the registered migration chain in
+memory so loaded data matches the current schema. Products that need truly
+unversioned, non-migrated profiles should supply a product-specific loader
+override.
+
+## Development
+
+Run the package checks from the `flex/public/flexcompute-core` directory:
+
+```bash
+uv run pytest
+uv run ruff check src tests
+```

flexcompute_core-0.0.1.dev2/pyproject.toml

@@ -0,0 +1,102 @@
+[build-system]
+requires = ["scikit_build_core==1.0.3"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "flexcompute-core"
+version = "0.0.1.dev2"
+authors = [{ name = "Flexcompute Inc.", email = "support@flexcompute.com" }]
+description = "Shared internal modules for Flexcompute Python packages."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  # Shared core.
+  "pydantic>=2.10.3,<3",
+  "tomlkit>=0.13.2,<0.16.0",
+  # Temporary migrated EM contracts under flexcompute.core._migration.em.
+  "autograd>=1.7.0,<2.0.0",
+  "boto3>=1.28.0,<2.0.0",
+  "click>=8.1.0,<9.0.0",
+  "cryptography==48.0.1; platform_system == 'Darwin' and platform_machine == 'x86_64'",
+  "cryptography>=44.0.0,!=48.0.1; platform_system != 'Darwin' or platform_machine != 'x86_64'",
+  "dask>=2025.12.0,<2027.0.0",
+  "fastmcp>=3.4.4,<4",
+  "filelock>=3.20.1,<4.0.0",
+  "h5netcdf>=1.0.2,<2.0.0",
+  "h5py>=3.0.0,<3.17; python_version < '3.14'",
+  "h5py>=3.16.0,<3.17; python_version >= '3.14'",
+  "importlib-metadata>=6.0.0,<10.0.0",
+  "joblib>=1.5.3,<2.0.0",
+  "matplotlib>=3.10.0,<4.0.0",
+  "numpy>=2.2.6,<2.5.0",
+  "pandas>=2.2,<4.0",
+  "pydantic-settings>=2.10.0,<3.0.0",
+  "pyjwt>=2.10.1,<3.0.0",
+  "pyroots>=0.5.0,<0.6.0",
+  "PyYAML>=6.0.3,<7.0.0",
+  "requests>=2.31.0,<3.0.0",
+  "responses>=0.25.8,<0.27.0",
+  "rich>=13.0,<16.0",
+  "scipy>=1.14,<2.0,!=1.15.0,!=1.15.1,!=1.15.2",
+  "shapely>=2.1.0,<3.0",
+  "toml>=0.10.2,<0.11.0",
+  "typing-extensions>=4.15.0,<5.0.0",
+  "xarray>=2023.08,<2026.8.0",
+]
+
+[tool.scikit-build]
+cmake.version = ">=3.15"
+wheel.cmake = false
+wheel.packages = ["src/flexcompute"]
+minimum-version = "build-system.requires"
+
+[dependency-groups]
+dev = [
+  "pyrefly==1.3.0",
+  "pytest>=8.1,<10.0.0",
+  "ruff==0.14.1",
+  "scipy-stubs>=1.15.3,<2.0",
+]
+
+[tool.uv]
+default-groups = ["dev"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+# Pin the rule set instead of extending ruff's default selection, which changes
+# between ruff releases.
+select = ["E", "F", "B", "I", "UP", "W"]
+
+[tool.ruff.lint.per-file-ignores]
+# The temporary migrated EM tree keeps the pyflakes-only baseline it moved in with.
+"src/flexcompute/core/_migration/**" = ["B", "E", "I", "UP", "W"]
+"tests/_migration/**" = ["B", "E", "I", "UP", "W"]
+
+[tool.pyrefly]
+project-includes = ["src/flexcompute/core/_migration/em"]
+python-version = "3.10.0"
+preset = "off"
+ignore-missing-imports = ["*"]
+
+[tool.pyrefly.errors]
+# The migrated EM tree still contains legacy unannotated callables and attributes. Keep
+# the annotation-presence rules disabled until that baseline is migrated.
+deprecated = "error"
+redundant-cast = "error"
+redundant-condition = "error"
+invalid-literal = "error"
+unnecessary-type-conversion = "error"
+bad-raise = "error"
+bad-keyword-argument = "error"
+invalid-syntax = "error"
+implicit-any-attribute = "error"
+invalid-argument = "error"
+bad-override-param-name = "error"
+not-required-key-access = "error"

flexcompute_core-0.0.1.dev2/src/flexcompute/core/_migration/__init__.py

@@ -0,0 +1 @@
+"""Temporary migration-only namespace for the first flexcompute development release."""

flexcompute_core-0.0.1.dev2/src/flexcompute/core/_migration/em/__init__.py

@@ -0,0 +1 @@
+"""Temporary migrated EM contracts for the first flexcompute development release."""

flexcompute_core-0.0.1.dev2/src/flexcompute/core/_migration/em/numerical/README.md

@@ -0,0 +1,109 @@
+# flexcompute.core._migration.em.numerical
+
+`flexcompute.core._migration.em.numerical` owns portable numerical kernels and
+deterministic schema-level EM conventions shared across packages. These are the
+formulas, sign conventions, and result interpretations that would otherwise be
+duplicated across runtime consumers.
+
+```mermaid
+flowchart TD
+  Public["public tidy3d"]
+  Solver["em_solver"]
+  Schema["flexcompute.core._migration.em.schema"]
+  Adapter["flexcompute.core._migration.em.numerical.schema"]
+  Raw["flexcompute.core._migration.em.numerical.raw"]
+
+  Public --> Raw
+  Solver --> Raw
+  Schema --> Raw
+  Schema --> Adapter
+  Adapter --> Raw
+```
+
+Paths below are relative to this directory unless they begin with `flex/` or
+`src/`.
+
+## Layers
+
+| Layer | Primary input | May import |
+| --- | --- | --- |
+| `raw` | arrays, scalars, simple typed payloads | third-party array libraries only |
+| `schema` | `flexcompute.core._migration.em.schema` model instances | `flexcompute.core._migration.em.schema` and `raw` |
+
+A schema adapter unpacks a model into keyword scalars once, then delegates the
+arithmetic: `schema/source_time.py:10-23` against the keyword-only raw
+signature it calls at `raw/source_time.py:10-22`.
+
+The split is contract-enforced, and the enforcement is deliberately asymmetric.
+
+| Contract | Asserts |
+| --- | --- |
+| `migrated-em-raw-numerical` | `numerical.raw` imports none of `tidy3d`, `flexcompute.rf`, `tidy3d_extras`, `flexcompute.core._migration.em.schema`, `em_solver` |
+| `flexcompute-core` | `flexcompute.core._migration.em` imports no public product and no runtime consumer; `flexcompute.core._migration.em.schema` is allowed within the package |
+
+Both live in `flex/utils/repository-tests/compute/.importlinter` and are checked
+by import-linter across the whole EM import graph, so a breach is reported
+wherever the import is written rather than only when this package's own tests
+run.
+
+## Consumers
+
+| Consumer | Entry point | Example |
+| --- | --- | --- |
+| public Tidy3D | `raw` | `flex/public/tidy3d/tidy3d/components/source/time.py:249` |
+| `flexcompute.core._migration.em.schema` | `raw`, or `schema` where a model must be unpacked | `flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/data/monitor_data.py:78-82`; `flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/source/time.py:13` |
+| `em_solver` | `raw` | in `src/Tidy3DCore/em-solver/em_solver/`: `eme_kernels.py:9`, `setup.py:25`, `point_cloud.py:13` |
+
+Public Tidy3D calls `raw` directly instead of owning a public adapter
+namespace. Only `flexcompute.core._migration.em.schema` has an adapter layer, and only where a schema
+model has to be unpacked first.
+
+## Conventions owned here
+
+| Convention | Kernel | Behavior |
+| --- | --- | --- |
+| power and Poynting | `raw/field_data.py:14-17`, `:33-46` | `0.5 * E x H*`, complex. The kernels conjugate but do not take the real part. |
+| planar monitor flux correction | `schema/field_data.py` | Preserves the centered Yee-grid flux convention after fields are interpolated to the exact monitor plane. |
+| colocated integration | `raw/mode.py:10-16` | `colocate=None` means `True`; `colocate` and `use_colocated_integration` combine with OR, not AND. Resolver at `:19-31`: an explicit argument wins, otherwise any colocated monitor makes the call colocated. |
+| snap margin | `raw/microwave.py:8-11` | `(2, 2, 2)` when field data is colocated, `(0, 0, 0)` otherwise, keeping automatic current paths off interpolated H fields near metal surfaces (call site and reason: `flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/microwave/path_integrals/mode_plane_analyzer.py:60-62`). |
+| current sign | `raw/microwave.py:14-17` | Opposite the voltage polarity, because current flows from the plus to the minus terminal (`flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/microwave/path_integrals/integrals/auto.py:79-84`). The voltage integral takes the polarity unchanged at `:63`. |
+| FDTD result diagnostics | `schema/solver_diagnostics.py` | Maps schema simulation context and solver completion flags to shared warning messages without owning logging. |
+
+Read the kernel when the exact behavior matters; this table routes, it does not
+restate.
+
+## What stays out of raw
+
+`raw` owns conventions duplicated in Python across public Tidy3D,
+`flexcompute.core._migration.em.schema`, and `em_solver`. A source family whose evaluation is owned by
+a native runtime is not duplicated Python convention, so its wrapper stays at
+the runtime boundary instead.
+
+`BroadbandPulse` is the worked example. Public Tidy3D delegates pulse
+evaluation to the extras native extension at
+`flex/public/tidy3d/tidy3d/components/source/time.py:681-692`; the schema class
+raises `SetupError` at
+`flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/source/time.py:649-655`.
+There is no shared Python kernel between the two, and moving runtime-owned
+implementation detail into `raw` would cost `raw` its product-neutrality.
+
+## Validation
+
+```bash
+uv run --project flex/public/flexcompute-core pytest flex/public/flexcompute-core/tests/_migration/em
+
+# The layer split is an import contract, so it needs the whole EM graph rather
+# than this package alone. From a full checkout:
+PYTHONPATH=flex/utils/repository-tests/compute \
+  python3 -m repository_tests.compute.import_boundaries
+```
+
+The contract runner exits 2 in a narrow worktree that does not contain every
+package root, so run it from a full checkout or let CI run it.
+
+| Test or contract | Covers |
+| --- | --- |
+| the `migrated-em` and `migrated-em-raw-numerical` contracts | the layer split |
+| `flex/public/flexcompute-core/tests/_migration/em/test_shared_numerical_kernels.py` | the conventions above, at `:25` (power and overlap signs and conjugation), `:280` (mode sorting and colocation), `:315` (path-integral sign and margin) |
+| `flex/public/flexcompute-core/tests/_migration/em/test_shared_numerical_mirrors.py` | the same behavior at the consumer and schema-wrapper level, mirroring the equivalent public Tidy3D client tests |
+| `flex/public/flexcompute-core/tests/_migration/em/test_schema_field_data_numerics.py` | planar field-monitor flux correction and its deliberate no-op cases |

flexcompute_core-0.0.1.dev2/src/flexcompute/core/_migration/em/numerical/__init__.py

@@ -0,0 +1 @@
+"""Shared numerical kernels and schema-facing numerical adapters for EM packages."""

flexcompute_core-0.0.1.dev2/src/flexcompute/core/_migration/em/numerical/raw/__init__.py

@@ -0,0 +1 @@
+"""Product-neutral shared numerical kernels."""

flexcompute_core-0.0.1.dev2/src/flexcompute/core/_migration/em/numerical/raw/diffraction.py

@@ -0,0 +1,55 @@
+"""Shared diffraction-order numerical kernels."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+COS_THETA_THRESH = 1e-5
+C_0 = 2.99792458e14
+
+
+def shifted_orders(orders: tuple[int, ...], bloch_vec: float | np.ndarray) -> np.ndarray:
+    """Return diffraction orders shifted by the Bloch vector."""
+
+    return bloch_vec + np.atleast_2d(orders).T
+
+
+def reciprocal_coords_from_epsilon(
+    orders: Any,
+    *,
+    size: float,
+    bloch_vec: float | np.ndarray,
+    frequency: float,
+    epsilon: complex,
+) -> np.ndarray:
+    """Return normalized reciprocal coordinates from order, Bloch, and epsilon data."""
+
+    if size == 0:
+        return np.atleast_2d(0)
+    order_tuple = tuple(int(order) for order in np.atleast_1d(orders))
+    bloch_array = shifted_orders(order_tuple, bloch_vec)
+    return bloch_array / size * C_0 / frequency / np.real(np.sqrt(epsilon))
+
+
+def amplitude_norm(theta_data: np.ndarray, eta: np.ndarray | complex) -> np.ndarray:
+    """Return diffraction amplitude normalization."""
+
+    cos_theta = np.cos(np.nan_to_num(theta_data))
+    cos_theta[cos_theta <= COS_THETA_THRESH] = np.inf
+    return 1.0 / np.sqrt(2.0 * np.asarray(eta)) / np.sqrt(cos_theta)
+
+
+def angle_is_propagating(angle_theta: float) -> bool:
+    """Return whether a diffraction angle is valid for a propagating order."""
+
+    return bool(np.isfinite(angle_theta) and np.cos(angle_theta) > COS_THETA_THRESH)
+
+
+def bloch_vec_at_freq(bloch_vec: float | np.ndarray, freq_index: int) -> float:
+    """Return scalar Bloch vector for a monitor frequency index."""
+
+    if np.ndim(bloch_vec) == 0:
+        return float(bloch_vec)
+    return float(np.asarray(bloch_vec)[freq_index])

flexcompute_core-0.0.1.dev2/src/flexcompute/core/_migration/em/numerical/raw/field_data.py

@@ -0,0 +1,204 @@
+"""Shared field-data numerical kernels."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+OUTER_DOT_BLOCK_TARGET_BYTES = 64 * 1024**2
+OUTER_DOT_BLOCK_MIN_SIZE = 8
+OUTER_DOT_BLOCK_MAX_SIZE = 64
+
+
+def complex_poynting(e1: Any, e2: Any, h1: Any, h2: Any) -> Any:
+    """Return the complex time-averaged Poynting component ``0.5 E x H*``."""
+
+    return 0.5 * (e1 * h2.conj() - e2 * h1.conj())
+
+
+def instantaneous_power_flow(
+    E: tuple[np.ndarray, np.ndarray],
+    H: tuple[np.ndarray, np.ndarray],
+    dS: tuple[np.ndarray, np.ndarray],
+) -> np.ndarray:
+    """Compute instantaneous power flow for real fields."""
+
+    dS_EuHv, dS_EvHu = dS
+    Eu, Ev = E
+    Hu, Hv = H
+    return np.sum((Eu * Hv) * dS_EuHv - (Ev * Hu) * dS_EvHu, axis=(-2, -1))
+
+
+def complex_power_flow(
+    E: tuple[np.ndarray, np.ndarray],
+    H: tuple[np.ndarray, np.ndarray],
+    dS: tuple[np.ndarray, np.ndarray],
+) -> np.ndarray:
+    """Compute ``0.5 * E x H*`` integrated with Yee-grid area elements."""
+
+    dS_EuHv, dS_EvHu = dS
+    Eu, Ev = E
+    Hu, Hv = H
+    return 0.5 * np.sum(
+        (Eu * np.conj(Hv)) * dS_EuHv - (Ev * np.conj(Hu)) * dS_EvHu,
+        axis=(-2, -1),
+    )
+
+
+def dot(
+    E1: tuple[np.ndarray, np.ndarray],
+    H1: tuple[np.ndarray, np.ndarray],
+    E2: tuple[np.ndarray, np.ndarray],
+    H2: tuple[np.ndarray, np.ndarray],
+    dS: tuple[np.ndarray, np.ndarray],
+    conjugate: bool = False,
+    bidirectional: bool = True,
+) -> np.ndarray:
+    """Compute the modal overlap integral."""
+
+    dS_EuHv, dS_EvHu = dS
+    E1u, E1v = E1
+    H1u, H1v = H1
+    E2u, E2v = E2
+    H2u, H2v = H2
+
+    dS_EuHv_flat = np.asarray(dS_EuHv).reshape(-1)
+    dS_EvHu_flat = np.asarray(dS_EvHu).reshape(-1)
+
+    if bidirectional:
+        term_specs = (
+            (0.25, E1u, H2v, dS_EuHv_flat),
+            (0.25, H1v, E2u, dS_EuHv_flat),
+            (-0.25, E1v, H2u, dS_EvHu_flat),
+            (-0.25, H1u, E2v, dS_EvHu_flat),
+        )
+    else:
+        term_specs = (
+            (0.5, E1u, H2v, dS_EuHv_flat),
+            (-0.5, E1v, H2u, dS_EvHu_flat),
+        )
+
+    batch_shape = np.broadcast_shapes(
+        *(left.shape[:-2] for _, left, _, _ in term_specs),
+        *(right.shape[:-2] for _, _, right, _ in term_specs),
+    )
+    dtype = np.result_type(
+        *(a.dtype for _, a, _, _ in term_specs),
+        *(a.dtype for _, _, a, _ in term_specs),
+        *(d.dtype for _, _, _, d in term_specs),
+    )
+    result = np.zeros(batch_shape, dtype=dtype)
+
+    for coeff, left, right, d_area in term_specs:
+        left_flat = left.reshape(*left.shape[:-2], -1)
+        right_flat = right.reshape(*right.shape[:-2], -1)
+        if conjugate:
+            left_flat = np.conj(left_flat)
+        result += (
+            coeff
+            * ((left_flat * d_area)[..., np.newaxis, :] @ right_flat[..., :, np.newaxis])[..., 0, 0]
+        )
+
+    return result
+
+
+def outer_dot(
+    E1: tuple[np.ndarray, np.ndarray],
+    H1: tuple[np.ndarray, np.ndarray],
+    E2: tuple[np.ndarray, np.ndarray],
+    H2: tuple[np.ndarray, np.ndarray],
+    dS: tuple[np.ndarray, np.ndarray],
+    conjugate: bool = False,
+    bidirectional: bool = True,
+) -> np.ndarray:
+    """Compute a pairwise modal-overlap matrix."""
+
+    E1u, E1v = E1
+    H1u, H1v = H1
+    E2u, E2v = E2
+    H2u, H2v = H2
+    dS_EuHv, dS_EvHu = dS
+
+    n_modes_1 = E1u.shape[-3]
+    n_modes_2 = E2u.shape[-3]
+    broadcast_shape = E1u.shape[:-3]
+    num_grid_points = E1u.shape[-2] * E1u.shape[-1]
+    dtype = np.result_type(
+        E1u.dtype,
+        E1v.dtype,
+        H1u.dtype,
+        H1v.dtype,
+        E2u.dtype,
+        E2v.dtype,
+        H2u.dtype,
+        H2v.dtype,
+        np.asarray(dS_EuHv).dtype,
+        np.asarray(dS_EvHu).dtype,
+    )
+
+    S = np.zeros((*broadcast_shape, n_modes_1, n_modes_2), dtype=dtype)
+    if n_modes_1 == 0 or n_modes_2 == 0:
+        return S
+
+    if conjugate:
+        E1u, E1v = np.conj(E1u), np.conj(E1v)
+        H1u, H1v = np.conj(H1u), np.conj(H1v)
+
+    itemsize = np.dtype(dtype).itemsize
+    if num_grid_points == 0:
+        block_size = OUTER_DOT_BLOCK_MAX_SIZE
+    else:
+        block_size = int(OUTER_DOT_BLOCK_TARGET_BYTES // (num_grid_points * itemsize))
+        block_size = max(OUTER_DOT_BLOCK_MIN_SIZE, block_size)
+        block_size = min(OUTER_DOT_BLOCK_MAX_SIZE, block_size)
+
+    block_size_left = min(n_modes_1, block_size)
+    block_size_right = min(n_modes_2, block_size)
+
+    dS_EuHv_flat = np.asarray(dS_EuHv).reshape(-1)
+    dS_EvHu_flat = np.asarray(dS_EvHu).reshape(-1)
+    if dS_EuHv_flat.size != num_grid_points or dS_EvHu_flat.size != num_grid_points:
+        raise ValueError("Tangential area shape mismatch in blocked outer_dot kernel.")
+
+    num_batches = int(np.prod(broadcast_shape, dtype=int)) if broadcast_shape else 1
+    out_flat = S.reshape(num_batches, n_modes_1, n_modes_2)
+
+    if bidirectional:
+        term_specs = (
+            (0.25, E1u, H2v, dS_EuHv_flat),
+            (0.25, H1v, E2u, dS_EuHv_flat),
+            (-0.25, E1v, H2u, dS_EvHu_flat),
+            (-0.25, H1u, E2v, dS_EvHu_flat),
+        )
+    else:
+        term_specs = (
+            (0.5, E1u, H2v, dS_EuHv_flat),
+            (-0.5, E1v, H2u, dS_EvHu_flat),
+        )
+
+    flattened_terms = tuple(
+        (
+            coeff,
+            left.reshape(num_batches, n_modes_1, num_grid_points),
+            right.reshape(num_batches, n_modes_2, num_grid_points),
+            d_area,
+        )
+        for coeff, left, right, d_area in term_specs
+    )
+
+    for batch_idx in range(num_batches):
+        out_batch = out_flat[batch_idx]
+        for coeff, left_term, right_term, d_area in flattened_terms:
+            left_batch = left_term[batch_idx]
+            right_batch = right_term[batch_idx]
+            for i0 in range(0, n_modes_1, block_size_left):
+                i0_end = min(i0 + block_size_left, n_modes_1)
+                left_block = left_batch[i0:i0_end]
+                for i1 in range(0, n_modes_2, block_size_right):
+                    i1_end = min(i1 + block_size_right, n_modes_2)
+                    right_block = right_batch[i1:i1_end]
+                    weighted_right = right_block * d_area
+                    out_batch[i0:i0_end, i1:i1_end] += coeff * (left_block @ weighted_right.T)
+
+    return S