diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index f5f89f9..732baed 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -34,12 +34,11 @@ jobs:
           mobilitydb-ref: master
           build-libmeos: "true"
 
-      - name: Derive the streaming-relevance baseline from the catalog
-        # The facade generator reads tools/baseline/streaming-relevance-baseline.json; derive
-        # it from the master catalog with the deterministic classifier so the generator input
-        # tracks master too. The baseline is gitignored — it only ever exists as a build artifact.
+      - name: Stage the derived MEOS catalog
+        # codegen_jvm.py reads tools/meos-idl.json; place the derived catalog there so its
+        # wiring is unchanged. The catalog is gitignored — it only ever exists as a build artifact.
         run: |
-          tools/regen_baseline.sh "${{ steps.provision.outputs.catalog-path }}"
+          cp "${{ steps.provision.outputs.catalog-path }}" tools/meos-idl.json
           echo "LD_LIBRARY_PATH=/usr/local/lib" >> "$GITHUB_ENV"
 
       - name: Check out JMEOS at master
@@ -71,7 +70,7 @@ jobs:
             -DgroupId=org.jmeos -DartifactId=meos -Dversion=1.0 -Dpackaging=jar
 
       - name: Build + generate + smoke tests
-        # generate-sources runs the facade generator over the installed jar's surface ∩ baseline;
+        # generate-sources runs codegen_jvm.py --engine flink over the installed jar's full surface;
         # the smoke tests exercise the facades against the freshly built libmeos from /usr/local/lib.
         working-directory: flink-processor
         run: mvn -B -Dmeos.lib.dir=/usr/local/lib -Dmeos.enabled=true clean test
diff --git a/.gitignore b/.gitignore
index 96d7870..7ed2aac 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,6 +13,6 @@ __pycache__/
 # Maven build output
 flink-processor/target/
 
-# Derived generator input — the streaming-relevance baseline is regenerated in CI
-# from the master MEOS catalog (tools/regen_baseline.sh), never committed.
-tools/baseline/streaming-relevance-baseline.json
+# Derived generator input — the MEOS catalog is staged in CI from upstream
+# MobilityDB master (provision-meos), never committed.
+tools/meos-idl.json
diff --git a/GENERATION.md b/GENERATION.md
index 00889ec..684c7d4 100644
--- a/GENERATION.md
+++ b/GENERATION.md
@@ -19,35 +19,35 @@ equivalence probe).
 ## MobilityFlink scope: generated MEOS facades over the JMEOS surface
 
 MobilityFlink is a **consumer** binding: it binds the **JMEOS jar** (the JVM FFI projection
-of the catalog), not MEOS-API directly. Its generator **`tools/codegen_facades.py`** reads
-the bundled JMEOS raw-FFI surface (intersected with the streaming-relevance baseline) and
-emits the `org.mobilitydb.meos.MeosOps*` 1:1 forwarder facades the Flink processor consumes.
-The facades are a *consumer* projection (they live here, not in JMEOS, so the JMEOS FFI line
-and the facade line do not diverge).
-
-## The streaming-relevance baseline (generator input)
-
-`tools/codegen_facades.py` emits a facade only for functions in the
-**streaming-relevant** tiers, read from `tools/baseline/streaming-relevance-baseline.json`.
-That baseline is itself **generated and reproducible** — it is not a hand-maintained
-list. It is produced by **`tools/classify_streaming_relevance.py`**, a deterministic
-classifier: the tier of a function is decided purely by its name, its object-model role,
-and its number of temporal parameters (zero per-function judgement), so the same MEOS
-catalog always yields the same baseline.
+of the catalog), not MEOS-API directly. Its generator is the shared
+**`tools/codegen_jvm.py --engine flink`**, the single generator vendored identically by every
+JVM binding (MobilitySpark, MobilityFlink, MobilityKafka); the `flink` and `kafka` engines
+emit the `org.mobilitydb.meos.MeosOps*` 1:1 forwarder facades the streaming processors
+consume. The facades are a *consumer* projection (they live here, not in JMEOS, so the JMEOS
+FFI line and the facade line do not diverge).
+
+## Full surface, grouped by the catalog object model
+
+`codegen_jvm.py --engine flink` emits a facade for **every** function on the bundled JMEOS
+`functions.GeneratedFunctions` surface, grouped by the MEOS-API catalog object model: one
+`MeosOps<Class>` per object-model class plus one `MeosOpsFree<Header>` per source header for
+the free functions, with a shared `MeosOpsRuntime` that probes libmeos once per JVM. Each
+forwarder carries a runtime guard: functions whose catalog return type is sequence-typed
+(build a whole `TSequence`/`SeqSet`, inherently non-streamable) throw
+`UnsupportedOperationException`; all others forward to `GeneratedFunctions` behind the
+`MEOS_AVAILABLE` probe. The class/role/header are read straight from the catalog's
+`objectModel`, and the sequence check from `returnType.canonical` — no separate classifier.
 
 The full input chain, from upstream MobilityDB master:
 
 ```
 MobilityDB @ master
   → provision-meos (MEOS-API/run.py over the MEOS headers)  → meos-idl.json  (the catalog)
-  → tools/classify_streaming_relevance.py                   → tools/baseline/streaming-relevance-baseline.json
-  → tools/codegen_facades.py  (jar-surface ∩ baseline)      → org.mobilitydb.meos.MeosOps* facades
+  → tools/codegen_jvm.py --engine flink  (full jar surface) → org.mobilitydb.meos.MeosOps* facades
 ```
 
-CI derives the baseline from the master catalog with `tools/regen_baseline.sh
-<path-to-meos-idl.json>` before the build; the baseline is gitignored, not committed.
-Because the classifier is deterministic, the same catalog regenerates it byte-for-byte, so
-a local refresh is: build the catalog from master with MEOS-API, then run the same script.
+CI stages the master-derived catalog to `tools/meos-idl.json` before the build; the catalog
+is gitignored, not committed.
 
 ## Generate-then-retire — the green-CI version is the probe
 
@@ -56,10 +56,10 @@ never wipe-first**: regenerate, build green, **prove generated ⊇ hand** agains
 green-CI version** (the test suite + the streaming benchmark), then retire the hand path.
 
 The `MeosOps*` facades are emitted at build time and are **not committed**: Maven
-`generate-sources` runs `tools/codegen_facades.py` into `target/generated-facades`, and
-`build-helper` adds it as a source root. Only the generator and its `tools/` classifier are
-tracked; the catalog, the baseline and the JMEOS jar are all derived in CI, and the sole
-hand-written class under `org.mobilitydb.meos` is `MeosSetSetJoin`.
+`generate-sources` runs `tools/codegen_jvm.py --engine flink` into `target/generated-facades`,
+and `build-helper` adds it as a source root. Only the generator is tracked; the catalog and
+the JMEOS jar are all derived in CI, and the sole hand-written class under
+`org.mobilitydb.meos` is `MeosSetSetJoin`.
 
 ## Surface match
 
diff --git a/flink-processor/pom.xml b/flink-processor/pom.xml
index 2245525..92d8079 100644
--- a/flink-processor/pom.xml
+++ b/flink-processor/pom.xml
@@ -221,13 +221,15 @@
                         <configuration>
                             <executable>python3</executable>
                             <arguments>
-                                <argument>${project.basedir}/../tools/codegen_facades.py</argument>
+                                <argument>${project.basedir}/../tools/codegen_jvm.py</argument>
+                                <argument>--engine</argument>
+                                <argument>flink</argument>
+                                <argument>--catalog</argument>
+                                <argument>${project.basedir}/../tools/meos-idl.json</argument>
                                 <argument>--jar</argument>
                                 <argument>${settings.localRepository}/org/jmeos/meos/1.0/meos-1.0.jar</argument>
                                 <argument>--out</argument>
                                 <argument>${project.build.directory}/generated-facades</argument>
-                                <argument>--engine</argument>
-                                <argument>flink</argument>
                             </arguments>
                         </configuration>
                     </execution>
diff --git a/tools/classify_streaming_relevance.py b/tools/classify_streaming_relevance.py
deleted file mode 100755
index 3690fff..0000000
--- a/tools/classify_streaming_relevance.py
+++ /dev/null
@@ -1,321 +0,0 @@
-#!/usr/bin/env python3
-"""Classify the MEOS public API into streaming tiers — the reproducible
-producer of ``tools/baseline/streaming-relevance-baseline.json``.
-
-The baseline is the generator input consumed by ``codegen_facades.py``
-(which emits a facade only for the streaming-relevant tiers). This script
-is deterministic: the tier of a function is decided purely by its name,
-its object-model role, and the number of temporal parameters — there is
-zero per-function judgement, so the same MEOS catalog always yields the
-same baseline.
-
-Usage:
-    classify_streaming_relevance.py <meos-idl.json> [-o <out.json>]
-                                    [--source-ref <label>]
-
-``<meos-idl.json>`` is the MEOS-API catalog produced by running
-``MEOS-API/run.py`` over the MEOS headers at the commit recorded in
-``tools/meos-source-commit.txt`` (see GENERATION.md for the full chain).
-The output defaults to stdout. ``--source-ref`` records portable
-provenance in the artifact instead of an absolute local path.
-"""
-import argparse
-import json
-import re
-import sys
-from collections import Counter, defaultdict
-from os.path import basename
-
-TIERS = ['stateless', 'bounded-state', 'windowed', 'cross-stream',
-         'sequence-only', 'io-meta', 'internal', 'ambiguous']
-
-PUBLIC_HEADERS = {
-    'meos.h', 'meos_geo.h', 'meos_cbuffer.h', 'meos_npoint.h',
-    'meos_pose.h', 'meos_rgeo.h', 'meos_transform.h', 'meos_catalog.h',
-}
-
-TEMPORAL_TYPES = (
-    'Temporal', 'TInstant', 'TSequence', 'TSequenceSet',
-    'TInt', 'TFloat', 'TBool', 'TText',
-    'TGeo', 'TGeoPoint', 'TGeompoint', 'TGeogpoint',
-    'TGeometry', 'TGeography',
-    'TCbuffer', 'TNpoint', 'TPose', 'TRGeometry',
-)
-
-
-def is_temporal(t):
-    s = t.get('canonical', t.get('c', ''))
-    return any(re.search(rf'\b{tt}\b', s) for tt in TEMPORAL_TYPES)
-
-
-def is_sequence_typed(t):
-    s = t.get('canonical', t.get('c', ''))
-    return 'TSequence' in s or 'SeqSet' in s
-
-
-def classify(fn, fn_role):
-    name = fn['name']
-    header = fn['file']
-    if header not in PUBLIC_HEADERS:
-        return ('internal', 'high', f'header {header} not public')
-
-    role = fn_role.get(name)
-    ret = fn['returnType']
-    params = fn['params']
-    n_temporal_params = sum(1 for p in params if is_temporal(p))
-    ret_is_temporal = is_temporal(ret)
-    ret_is_seq = is_sequence_typed(ret)
-
-    # --- IO / parsing / serialization ---
-    if role == 'output' or re.search(
-        r'_(in|out|recv|send|as_text|as_hexwkb|as_wkb|as_mfjson|as_ewkt|as_geojson|from_(wkb|hexwkb|text|mfjson|ewkt|geojson|wkt))$', name):
-        return ('io-meta', 'high', 'IO/serialization')
-    if 'mfjson' in name or 'wkb' in name or 'ewkt' in name or '_to_string' in name:
-        return ('io-meta', 'high', 'name has IO token')
-    # MEOS lifecycle / errno / array container helpers / rtree / ensure_
-    if re.match(r'^(meos_|ensure_|rtree_|skiplist_|meostype_|temptype_)', name):
-        return ('io-meta', 'high', 'MEOS infra / catalog / utility')
-
-    # --- Type conversions ---
-    if role == 'conversion':
-        return ('stateless', 'high', 'role=conversion')
-    if re.search(r'_to_(timestamptz|date|float|int|bigint|text|bool|tstzspan|span|stbox|tbox|tgeompoint|tgeogpoint|geo|geom|geog|set)$', name):
-        return ('stateless', 'high', 'name pattern is _to_<type>')
-
-    # --- Accessor ---
-    if role == 'accessor':
-        return ('bounded-state', 'high', 'role=accessor')
-
-    # --- Restriction (at/minus/delete) ---
-    if role == 'restriction':
-        return ('bounded-state', 'high', 'role=restriction')
-    if re.match(r'^(minus|at|delete)_', name) or '_at_' in name or '_minus_' in name or '_delete_' in name:
-        return ('bounded-state', 'high', 'restriction name pattern')
-
-    # --- Aggregate (windowed by definition) ---
-    if role == 'aggregate':
-        return ('windowed', 'high', 'role=aggregate')
-
-    # --- Ever / Always (e* / a* AND ever_/always_) ---
-    if name.startswith('ever_') or name.startswith('always_'):
-        if n_temporal_params >= 2:
-            return ('cross-stream', 'high', 'ever/always over 2 temporals')
-        return ('windowed', 'high', 'ever/always over 1 temporal')
-    if re.match(r'^[ea](intersects|contains|disjoint|touches|within|covers|crosses|overlaps|dwithin)_', name):
-        if n_temporal_params >= 2:
-            return ('cross-stream', 'high', 'ever/always spatial-rel on 2 temporals')
-        return ('bounded-state', 'high', 'ever/always spatial-rel on 1 temporal')
-
-    # --- Predicate (other) ---
-    if role == 'predicate':
-        if n_temporal_params >= 2:
-            return ('cross-stream', 'high', 'predicate on 2 temporals')
-        return ('bounded-state', 'high', 'predicate on 1 temporal')
-
-    # --- Constructor ---
-    if role == 'constructor':
-        if ret_is_seq:
-            return ('sequence-only', 'high', 'constructor of TSequence/TSeqSet')
-        return ('stateless', 'high', 'constructor of instant/scalar')
-
-    # === Non-OO public functions, name-pattern fallbacks ===
-
-    # Set / span / spanset / tbox / stbox algebra (union, intersection,
-    # contains, overlaps, adjacent, position) - pure box/set algebra
-    if re.match(
-        r'^(union|intersection|difference|minus|contains|contained|overlaps|adjacent|'
-        r'left|right|overleft|overright|below|above|overbelow|overabove|front|back|'
-        r'overfront|overback|before|after|overbefore|overafter)_'
-        r'(set|span|spanset|tbox|stbox|date|timestamptz|int|bigint|float|text|bool|geo|geom|geog)',
-        name):
-        return ('stateless', 'high', 'set/span/box algebra (pure)')
-
-    # Numeric / text / bool ops on temporals (per-instant)
-    if re.match(
-        r'^t(int|float|number|text|bool)_(add|sub|mul|div|mod|abs|sqrt|round|ceil|floor|sign|neg|'
-        r'pow|exp|ln|log10|sin|cos|tan|degrees|radians|upper|lower|concat|and|or|not|xor|reverse|length)$',
-        name):
-        return ('stateless', 'high', 'temporal numeric/text/bool op')
-
-    # Temporal compare (teq, tne, tlt, tle, tgt, tge) - per-instant
-    if re.match(r'^t(eq|ne|lt|le|gt|ge)_', name):
-        return ('stateless', 'high', 'temporal comparison (per-instant)')
-
-    # Per-value comparison / hash on base / set / span / tbox
-    if re.match(
-        r'^(temporal|tfloat|tint|tbool|ttext|set|span|spanset|tbox|stbox|cbuffer|npoint|pose|'
-        r'date|geo|geom|geog|float|int|bigint|text|bool|timestamptz)_(eq|ne|cmp|lt|le|gt|ge|hash)',
-        name):
-        return ('stateless', 'high', 'scalar comparison/hash')
-
-    # Sequence-derived metrics (windowed)
-    if re.search(
-        r'_(length|cumulative_length|speed|integral|derivative|twavg|twmin|twmax|twsum|stops|'
-        r'min_dist|max_dist|nearest_approach|nearestapproach|granger)', name):
-        return ('windowed', 'high', 'sequence-derived metric')
-
-    # Trajectory / timespan / valueset / *_n / num_* — derived from full sequence
-    if re.search(r'_(trajectory|timespan|periods|periodset|valueset|num_(instants|sequences|values|timestamps))$', name):
-        return ('windowed', 'medium', 'derived from full sequence')
-
-    # Distance / NAD / NAI / shortestline
-    if re.match(r'^(nad|nai|shortestline|tdistance|distance)_', name):
-        if n_temporal_params >= 2:
-            return ('cross-stream', 'high', 'distance on 2 temporals')
-        return ('bounded-state', 'high', 'distance op')
-
-    # Constructor-like make / from_base / from_mfjson on instants
-    if re.search(r'(_make|_from_base|_make_array)$', name) or re.match(r'^geo_make', name) or re.match(r'^geom_make', name):
-        if ret_is_seq:
-            return ('sequence-only', 'medium', 'make-of-sequence')
-        return ('stateless', 'medium', 'make/from_base of instant/scalar')
-
-    # Shift / scale / round / fix / canonicalize / expand
-    if re.search(r'_(shift|scale|shift_scale|round|fix|canonicalize|expand|expandspace|expandtime|setbbox|setprecision)$', name) or \
-       re.search(r'_(shift|scale|shift_scale|round|fix|canonicalize|expand|expandspace|expandtime)_', name):
-        return ('stateless', 'high', 'transform/normalize (pure)')
-
-    # Geometry transformers (geom_to_*, geog_to_*, geo_*)
-    if re.match(r'^(geo|geom|geog|pose|cbuffer|npoint|stbox|tbox|set|span|spanset|float|int|bigint|text|bool|date|timestamptz)_', name):
-        # Default for base-type funcs without a more specific rule
-        return ('stateless', 'medium', 'base-type fn, default pure')
-
-    # Utility: copy / free / hash / compress / decompress
-    if re.search(r'_(copy|free|hash|compress|decompress|fix|valid|set_|setbbox)$', name):
-        return ('stateless', 'medium', 'utility')
-
-    # Topology "same_" predicate on box/temporal
-    if re.match(r'^same_', name):
-        if n_temporal_params >= 2:
-            return ('cross-stream', 'high', 'same predicate on 2 temporals')
-        return ('stateless', 'high', 'same predicate (pure box equality)')
-
-    # Temporal spatial relation lifted (returns a tbool)
-    if re.match(r'^t(intersects|contains|covers|disjoint|dwithin|touches|crosses|overlaps|within|equals)_', name):
-        if n_temporal_params >= 2:
-            return ('cross-stream', 'high', 'temporal spatial-rel lift on 2 temporals')
-        return ('bounded-state', 'high', 'temporal spatial-rel lift on 1 temporal')
-
-    # textcat / text-concat operator on temporals
-    if re.match(r'^textcat_', name):
-        return ('stateless', 'high', 'text concatenation (per-instant)')
-
-    # Temporal arithmetic operators (different name shapes: add_<X>_<Y>, sub_*, mul_*, div_*)
-    if re.match(r'^(add|sub|mul|div|mod)_(t(int|float|number)|int|float)', name):
-        return ('stateless', 'high', 'arithmetic op on temporal number (per-instant)')
-
-    # Position / topology relations — type-suffix-agnostic, signature-driven.
-    # Catches adjacent_numspan_tnumber, contained_tnumber_tbox, left_X_Y, etc.
-    if re.match(r'^(adjacent|contained|contains|overlaps|same|left|right|overleft|overright|'
-                r'before|after|overbefore|overafter|below|above|overbelow|overabove|'
-                r'front|back|overfront|overback)_', name):
-        if n_temporal_params >= 2:
-            return ('cross-stream', 'high', 'topology/position rel on 2 temporals')
-        if n_temporal_params == 1:
-            return ('bounded-state', 'high', 'topology/position rel on 1 temporal + scalar')
-        return ('stateless', 'high', 'topology/position rel on 2 scalars (box/span algebra)')
-
-    # Scalar arithmetic (add_date_int, add_timestamptz_interval, sub_*, mul_*)
-    if re.match(r'^(add|sub|mul|div|mod)_(date|timestamptz|int|bigint|float|interval)', name):
-        return ('stateless', 'high', 'scalar arithmetic')
-
-    # int32_cmp / int64_cmp / other scalar comparators with width suffix
-    if re.match(r'^(int32|int64|uint32|uint64|float32|float64)_(eq|ne|cmp|lt|le|gt|ge|hash)', name):
-        return ('stateless', 'high', 'scalar comparison with width suffix')
-
-    # cstring2text / text2cstring / pg_* casts / cstring_to_text
-    if re.match(r'^(cstring|text)2(cstring|text)|^cstring_to_|^text_to_cstring|^pg_', name):
-        return ('io-meta', 'high', 'string/CString conversion (low-level)')
-
-    # Last-resort: anything that returns a Datum / void / int errno-style without a temporal param = io-meta
-    # (numeric utility wrappers, MEOS internals exposed for codegen, error handling)
-    if n_temporal_params == 0 and not ret_is_temporal:
-        rc = ret.get('canonical', '') or ret.get('c', '')
-        if rc in ('int', 'bool', 'void', 'char *', 'const char *', 'Datum'):
-            return ('stateless', 'low', 'scalar in/out (default-stateless catch-all)')
-
-    return ('ambiguous', 'low', f'no rule (role={role}, hdr={header}, ntemp={n_temporal_params})')
-
-
-def build(cat, source_ref):
-    fn_role, fn_class = {}, {}
-    for cls_name, cls in cat['objectModel']['classes'].items():
-        for m in cls.get('methods', []):
-            fn = m['function']
-            fn_role[fn] = m.get('role')
-            fn_class.setdefault(fn, []).append(cls_name)
-
-    results = []
-    for fn in cat['functions']:
-        tier, conf, reason = classify(fn, fn_role)
-        results.append({
-            'name': fn['name'], 'file': fn['file'],
-            'role': fn_role.get(fn['name']),
-            'class': fn_class.get(fn['name'], []),
-            'tier': tier, 'confidence': conf, 'reason': reason,
-            'return_c': fn['returnType'].get('canonical', fn['returnType'].get('c')),
-            'n_params': len(fn['params']),
-        })
-
-    total = len(results)
-    public_rows = [r for r in results if r['tier'] != 'internal']
-    tot = Counter(r['tier'] for r in results)
-    pub_tot = Counter(r['tier'] for r in public_rows)
-    by_h = defaultdict(Counter)
-    for r in public_rows:
-        by_h[r['file']][r['tier']] += 1
-    streaming_relevant = sum(pub_tot[t] for t in ['stateless', 'bounded-state', 'windowed', 'cross-stream'])
-
-    return {
-        'schema_version': '0.1.0-draft',
-        'source_catalog': source_ref,
-        'source_catalog_function_count': total,
-        'classifier': 'v4',
-        'vocabulary': TIERS,
-        'public_headers': sorted(PUBLIC_HEADERS),
-        'rollup': {
-            'total': dict(tot),
-            'public_only': dict(pub_tot),
-            'public_by_header': {h: dict(c) for h, c in by_h.items()},
-            'headline_public': {
-                'streaming_relevant': streaming_relevant,
-                'sequence_only': pub_tot['sequence-only'],
-                'io_meta': pub_tot['io-meta'],
-                'ambiguous': pub_tot['ambiguous'],
-                'public_total': len(public_rows),
-            },
-        },
-        'functions': results,
-    }
-
-
-def main():
-    ap = argparse.ArgumentParser(description=__doc__,
-                                 formatter_class=argparse.RawDescriptionHelpFormatter)
-    ap.add_argument('catalog', help='meos-idl.json produced by MEOS-API/run.py')
-    ap.add_argument('-o', '--out', default='-',
-                    help='output baseline path (default: stdout)')
-    ap.add_argument('--source-ref', default=None,
-                    help='portable provenance recorded in the artifact '
-                         '(default: the catalog basename)')
-    a = ap.parse_args()
-
-    with open(a.catalog) as f:
-        cat = json.load(f)
-    artifact = build(cat, a.source_ref or basename(a.catalog))
-
-    text = json.dumps(artifact, indent=2) + '\n'
-    if a.out == '-':
-        sys.stdout.write(text)
-    else:
-        with open(a.out, 'w') as f:
-            f.write(text)
-        pub = artifact['rollup']['headline_public']
-        sys.stderr.write(
-            f"wrote {a.out}: {artifact['source_catalog_function_count']} fns, "
-            f"{pub['streaming_relevant']} streaming-relevant, "
-            f"{pub['ambiguous']} ambiguous\n")
-
-
-if __name__ == '__main__':
-    main()
diff --git a/tools/codegen_facades.py b/tools/codegen_facades.py
deleted file mode 100644
index d2365a5..0000000
--- a/tools/codegen_facades.py
+++ /dev/null
@@ -1,235 +0,0 @@
-#!/usr/bin/env python3
-"""Generate the org.mobilitydb.meos.MeosOps* streaming facades from the MEOS
-binding surface.
-
-North Star (meos-api-codegen-regularity): the streaming facade surface is a
-pure projection of the MEOS catalog and is GENERATED, never hand-written. The
-facades are 1:1 static forwarders to functions.GeneratedFunctions (the JMEOS
-FFI surface), so they always match the JMEOS jar bundled with this engine. The
-streaming-relevance baseline classifies each MEOS function into an object-model
-class and a streaming tier (stateless / bounded-state / windowed / cross-stream
-/ io-meta); that drives one Java class per object-model class plus one per
-source header for the free functions, with a shared MeosOpsRuntime that probes
-libmeos exactly once per JVM.
-
-This is the per-binding generator (the Flink/Kafka analogue of JMEOS'
-FunctionsGenerator and MobilitySpark's tools/codegen_spark_udfs.py): each
-engine runs it over the JMEOS jar it ships to regenerate its own facades, so
-the surface never drifts from the pin and is reproducible from the repo.
-
-Usage:
-  tools/codegen_facades.py --jar <JMEOS.jar> --out <module-dir> --engine <name>
-                           [--baseline <path>] [--package <pkg>]
-"""
-import argparse
-import json
-import os
-import re
-import subprocess
-from collections import Counter, defaultdict
-from pathlib import Path
-
-SIG_RE = re.compile(
-    r'^\s*public\s+static\s+(?P<ret>[\w\.<>\[\]]+)\s+(?P<name>\w+)\((?P<args>[^)]*)\)')
-
-# Streaming tiers that get a facade; sequence-only/internal/ambiguous are skipped.
-EMIT_TIERS = {'stateless', 'bounded-state', 'windowed', 'cross-stream', 'io-meta'}
-TIER_ORDER = {'stateless': 0, 'bounded-state': 1, 'windowed': 2,
-              'cross-stream': 3, 'io-meta': 4, 'sequence-only': 5}
-TIER_DOC = {
-    'stateless':     'Pure per-event; safe in any scalar position.',
-    'bounded-state': 'Per-event with bounded per-key state (MEOS handle).',
-    'windowed':      'Requires a window operator — caller wraps in an aggregate.',
-    'cross-stream':  'Pairwise across streams — caller wraps in a join.',
-    'sequence-only': 'Inherently non-streamable; honest marker.',
-    'io-meta':       'I/O / catalog / lifecycle helper.',
-}
-
-
-def short_type(t):
-    if t.startswith('java.lang.'):
-        return t[len('java.lang.'):]
-    return t.split('.')[-1] if '.' in t else t
-
-
-def parse_jmeos_signatures(jar):
-    """javap functions.GeneratedFunctions -> {name: {ret, arg_types}}."""
-    out = subprocess.run(
-        ['javap', '-cp', str(jar), 'functions.GeneratedFunctions'],
-        check=True, capture_output=True, text=True).stdout
-    jmeos = {}
-    for line in out.splitlines():
-        m = SIG_RE.match(line.rstrip(';'))
-        if m:
-            raw = m.group('args').strip()
-            jmeos[m.group('name')] = {
-                'ret': m.group('ret'),
-                'arg_types': [a.strip() for a in raw.split(',')] if raw else [],
-            }
-    return jmeos
-
-
-def header_to_class(h):
-    base = h.replace('.h', '').replace('meos_', '').replace('meos', 'core')
-    if base in ('', 'core'):
-        return 'MeosOpsFreeCore'
-    return 'MeosOpsFree' + ''.join(p.capitalize() for p in base.split('_'))
-
-
-def collect_imports(rows):
-    imports = {'functions.GeneratedFunctions'}
-    for r in rows:
-        for t in [r['java_ret']] + [a[0] for a in r['java_params']]:
-            if '.' in t and not t.startswith('java.lang.'):
-                imports.add(t.replace('[]', ''))
-    return sorted(i for i in imports if '.' in i)
-
-
-def emit_method(r, prop):
-    fname = r['name']
-    args = ', '.join(f'{short_type(t)} {n}' for (t, n) in r['java_params'])
-    call_args = ', '.join(n for (t, n) in r['java_params'])
-    ret = short_type(r['java_ret'])
-    L = ['    /**',
-         f'     * MEOS {{@code {fname}}} — tier <b>{r["tier"]}</b>.',
-         f'     * <p>{TIER_DOC.get(r["tier"], "")}</p>']
-    if r.get('role'):
-        L.append(f'     * <p>Object-model role: {{@code {r["role"]}}}.</p>')
-    L.append(f'     * <p>Classification: {r["reason"]}</p>')
-    L.append('     */')
-    if r['tier'] == 'sequence-only':
-        L += [f'    public static {ret} {fname}({args}) {{',
-              '        throw new UnsupportedOperationException(',
-              f'            "{fname} is sequence-only — not supported in a streaming context");',
-              '    }', '']
-    else:
-        ret_stmt = '' if ret == 'void' else 'return '
-        L += [f'    public static {ret} {fname}({args}) {{',
-              '        if (!MEOS_AVAILABLE) {',
-              '            throw new UnsupportedOperationException(',
-              f'                "{fname} requires libmeos — set -D{prop}=true");',
-              '        }',
-              f'        {ret_stmt}GeneratedFunctions.{fname}({call_args});',
-              '    }', '']
-    return L
-
-
-def emit_class(cls, rows, pkg, prop, banner):
-    tier_cnt = Counter(r['tier'] for r in rows)
-    L = [f'package {pkg};', '',
-         '/* AUTO-GENERATED by tools/codegen_facades.py — do not edit by hand.',
-         f' * {banner}',
-         f' * Methods emitted: {len(rows)} (' +
-         ' · '.join(f'{t}={c}' for t, c in tier_cnt.most_common()) + ')',
-         ' * Source: the bundled JMEOS functions.GeneratedFunctions surface',
-         ' *         ∩ the streaming-relevance baseline.',
-         ' */', '']
-    L += [f'import {i};' for i in collect_imports(rows)]
-    L += ['',
-          f'public final class {cls} {{', '',
-          '    public static final boolean MEOS_AVAILABLE = MeosOpsRuntime.MEOS_AVAILABLE;',
-          '',
-          f'    private {cls}() {{ /* utility */ }}', '']
-    for r in sorted(rows, key=lambda r: (TIER_ORDER.get(r['tier'], 99), r['name'])):
-        L += emit_method(r, prop)
-    L.append('}')
-    return '\n'.join(L) + '\n'
-
-
-def runtime_src(pkg, prop):
-    return f'''package {pkg};
-
-import functions.GeneratedFunctions;
-
-/* AUTO-GENERATED by tools/codegen_facades.py — do not edit by hand.
- * Shared runtime helper: owns the single MEOS_AVAILABLE static-init across all
- * generated MeosOps* facades, so libmeos is probed exactly once per JVM. */
-final class MeosOpsRuntime {{
-
-    static final boolean MEOS_AVAILABLE;
-
-    static {{
-        boolean enabled = Boolean.parseBoolean(
-                System.getProperty("{prop}", "true"));
-        boolean ok = false;
-        if (enabled) {{
-            try {{
-                GeneratedFunctions.meos_initialize();
-                ok = true;
-            }} catch (Throwable t) {{
-                ok = false;
-            }}
-        }}
-        MEOS_AVAILABLE = ok;
-    }}
-
-    private MeosOpsRuntime() {{ /* utility */ }}
-}}
-'''
-
-
-def main():
-    here = Path(__file__).resolve().parent
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument('--jar', required=True, help='JMEOS jar with functions.GeneratedFunctions')
-    ap.add_argument('--out', required=True, help='module dir (facades go to <out>/src/main/java/<pkg>)')
-    ap.add_argument('--engine', required=True, help='engine name -> the -Dmobility<engine>.meos.enabled toggle')
-    ap.add_argument('--baseline', default=str(here / 'baseline' / 'streaming-relevance-baseline.json'))
-    ap.add_argument('--package', default='org.mobilitydb.meos')
-    a = ap.parse_args()
-
-    prop = f'mobility{a.engine}.meos.enabled'
-    out_dir = Path(a.out) / 'src/main/java' / a.package.replace('.', '/')
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    jmeos = parse_jmeos_signatures(a.jar)
-    with open(a.baseline) as f:
-        baseline = json.load(f)
-
-    def join(rows):
-        emit, absent = [], []
-        for r in rows:
-            if r['name'] in jmeos:
-                sig = jmeos[r['name']]
-                emit.append({**r, 'java_ret': sig['ret'],
-                             'java_params': [(t, f'arg{i}') for i, t in enumerate(sig['arg_types'])]})
-            else:
-                absent.append(r['name'])
-        return emit, absent
-
-    streamable = [r for r in baseline['functions']
-                  if r['tier'] in EMIT_TIERS and r['tier'] != 'internal']
-    oo_rows, _ = join([r for r in streamable if r.get('class')])
-    free_rows, _ = join([r for r in streamable if not r.get('class')])
-
-    # Regenerate from scratch: drop stale MeosOps*.java, keep hand-written
-    # caller logic in the same package (e.g. MeosSetSetJoin.java).
-    for f in out_dir.glob('MeosOps*.java'):
-        f.unlink()
-
-    (out_dir / 'MeosOpsRuntime.java').write_text(runtime_src(a.package, prop))
-
-    by_class = defaultdict(list)
-    for r in oo_rows:
-        for c in r['class']:
-            by_class[c].append(r)
-    for cls, rows in sorted(by_class.items()):
-        (out_dir / f'MeosOps{cls}.java').write_text(
-            emit_class(f'MeosOps{cls}', rows, a.package, prop,
-                       f'MEOS object-model class: {cls}'))
-
-    by_header = defaultdict(list)
-    for r in free_rows:
-        by_header[r['file']].append(r)
-    for header, rows in sorted(by_header.items()):
-        cls = header_to_class(header)
-        (out_dir / f'{cls}.java').write_text(
-            emit_class(cls, rows, a.package, prop, f'Free functions from {header}'))
-
-    total = 1 + len(by_class) + len(by_header)
-    print(f'{a.engine}: emitted {total} facade classes into {out_dir} '
-          f'({len(by_class)} object-model + {len(by_header)} free + MeosOpsRuntime)')
-
-
-if __name__ == '__main__':
-    main()
diff --git a/tools/codegen_jvm.py b/tools/codegen_jvm.py
new file mode 100644
index 0000000..be1b6bd
--- /dev/null
+++ b/tools/codegen_jvm.py
@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+"""Unified MEOS-surface code generator for the MobilityDB JVM bindings.
+
+ONE generator, three engines, selected by ``--engine {spark|flink|kafka}``. Every
+JVM binding (MobilitySpark, MobilityFlink, MobilityKafka) vendors this identical
+file plus its ``codegen_spark_udfs.py`` sibling, so the generated surface can never
+drift between engines — the North Star that MEOS is the single source of truth and
+all bindings are GENERATED from it.
+
+  * ``spark``        -> the MobilitySpark SQL-UDF surface. This path delegates
+                        VERBATIM to the sibling ``codegen_spark_udfs.py``: the same
+                        code runs, so the emitted files are byte-identical to what
+                        that generator produces on its own.
+  * ``flink|kafka``  -> the thin ``MeosOps*`` Java static-forwarder facades.
+                        Covers the FULL jar surface (every
+                        functions.GeneratedFunctions symbol), grouped by the
+                        MEOS-API catalog object model: one class per object-model
+                        class plus one per source header for the free functions,
+                        plus the shared MeosOpsRuntime. flink and kafka differ ONLY
+                        by the ``-Dmobility<engine>.meos.enabled`` toggle string.
+
+Shared front-end (facade back-end only): load the catalog, list the jar symbols,
+and derive each function's object-model class / role / header directly from the
+catalog's ``objectModel``. The spark back-end owns its own catalog+jar front-end
+(it needs jar arities the facade parse does not), so nothing about it changes.
+
+Usage:
+  codegen_jvm.py --engine spark --catalog meos-idl.json --jar JMEOS.jar --out DIR
+  codegen_jvm.py --engine flink --catalog meos-idl.json --jar JMEOS.jar --out DIR
+  codegen_jvm.py --engine kafka --catalog meos-idl.json --jar JMEOS.jar --out DIR
+"""
+import argparse
+import importlib.util
+import json
+import re
+import subprocess
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+
+# ───────────────────────── shared front-end ─────────────────────────
+
+def load_catalog(path):
+    with open(path) as f:
+        return json.load(f)
+
+
+SIG_RE = re.compile(
+    r'^\s*public\s+static\s+(?P<ret>[\w\.<>\[\]]+)\s+(?P<name>\w+)\((?P<args>[^)]*)\)')
+
+
+def parse_jmeos_signatures(jar):
+    """javap functions.GeneratedFunctions -> {name: {ret, arg_types}} (jar SoT).
+
+    The jar is the ground truth of what the bundled JMEOS actually exposes, so the
+    facade surface is exactly the jar surface."""
+    out = subprocess.run(
+        ['javap', '-cp', str(jar), 'functions.GeneratedFunctions'],
+        check=True, capture_output=True, text=True).stdout
+    jmeos = {}
+    for line in out.splitlines():
+        m = SIG_RE.match(line.rstrip(';'))
+        if m:
+            raw = m.group('args').strip()
+            jmeos[m.group('name')] = {
+                'ret': m.group('ret'),
+                'arg_types': [a.strip() for a in raw.split(',')] if raw else [],
+            }
+    return jmeos
+
+
+_SEQ_RE = re.compile(r'\bTSequence\b')
+
+
+def seq_typed(canonical):
+    """Sequence-typed return: materializes a whole TSequence / *SeqSet, so the
+    function is inherently non-streamable (drives the sequence-only guard). Purely
+    catalog-derived from returnType.canonical — no name heuristics."""
+    s = canonical or ''
+    return bool(_SEQ_RE.search(s)) or 'SeqSet' in s
+
+
+def object_model_index(cat):
+    """Catalog-derived class / role / header / sequence index for the facades.
+
+    Returns (fn_class, fn_role, fn_header, fn_seq):
+      fn_class[name]  -> the object-model class name (e.g. 'TGeo', 'FloatSpan')
+                         or None if the function is a free/plumbing function.
+      fn_role[name]   -> the object-model role (constructor/accessor/... ) or None.
+      fn_header[name] -> the source header the catalog attributes the function to.
+      fn_seq[name]    -> True iff its return type is sequence-typed.
+
+    class/role come from objectModel.classes[*].methods[*] (each function appears
+    under exactly ONE class, agreeing with objectModel.functionToClass). The header
+    is the per-function 'file' field. The spark back-end does not use this — it
+    groups by doxygen @ingroup."""
+    om = cat['objectModel']
+    fn_class, fn_role, fn_header, fn_seq = {}, {}, {}, {}
+    for cls_name, cls in om['classes'].items():
+        for m in cls.get('methods', []):
+            fn = m['function']
+            fn_class.setdefault(fn, cls_name)
+            fn_role.setdefault(fn, m.get('role'))
+    for f in cat['functions']:
+        n = f['name']
+        fn_header[n] = f['file']
+        fn_seq[n] = seq_typed(f['returnType'].get('canonical',
+                                                   f['returnType'].get('c', '')))
+    return fn_class, fn_role, fn_header, fn_seq
+
+
+# ───────────────────────── spark back-end ─────────────────────────
+
+def run_spark(args):
+    """Delegate to the sibling codegen_spark_udfs.py so output is byte-identical.
+
+    The reference generator owns the whole catalog+jar front-end and the SQL-UDF
+    emit; running its own code (rather than a re-implementation) is what makes the
+    output provably identical to today's. Every binding vendors codegen_spark_udfs.py
+    next to this file, so the import target is always the sibling."""
+    spark_path = Path(__file__).resolve().parent / 'codegen_spark_udfs.py'
+    spec = importlib.util.spec_from_file_location('codegen_spark_udfs', spark_path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    argv = ['codegen_spark_udfs',
+            '--catalog', args.catalog,
+            '--out', args.out,
+            '--jar', args.jar]
+    if args.report:
+        argv.append('--report')
+    saved = sys.argv
+    try:
+        sys.argv = argv
+        mod.main()
+    finally:
+        sys.argv = saved
+
+
+# ───────────────────────── facade back-end ─────────────────────────
+
+def short_type(t):
+    if t.startswith('java.lang.'):
+        return t[len('java.lang.'):]
+    return t.split('.')[-1] if '.' in t else t
+
+
+def header_to_class(h):
+    """Free-function class name from the source header, split on '_' AND '.' so a
+    dotted internal header (e.g. postgres_ext_defs.in.h) yields a valid class."""
+    base = h.replace('.h', '').replace('meos_', '').replace('meos', 'core')
+    if base in ('', 'core'):
+        return 'MeosOpsFreeCore'
+    return 'MeosOpsFree' + ''.join(p.capitalize()
+                                   for p in re.split(r'[_.]', base) if p)
+
+
+def collect_imports(rows):
+    imports = {'functions.GeneratedFunctions'}
+    for r in rows:
+        for t in [r['java_ret']] + [a[0] for a in r['java_params']]:
+            if '.' in t and not t.startswith('java.lang.'):
+                imports.add(t.replace('[]', ''))
+    return sorted(i for i in imports if '.' in i)
+
+
+def emit_method(r, prop):
+    fname = r['name']
+    args = ', '.join(f'{short_type(t)} {n}' for (t, n) in r['java_params'])
+    call_args = ', '.join(n for (t, n) in r['java_params'])
+    ret = short_type(r['java_ret'])
+    L = ['    /**',
+         f'     * MEOS {{@code {fname}}}.']
+    if r.get('oo_class'):
+        L.append(f'     * <p>Object-model class: {{@code {r["oo_class"]}}}'
+                 + (f', role {{@code {r["role"]}}}' if r.get('role') else '')
+                 + '.</p>')
+    elif r.get('role'):
+        L.append(f'     * <p>Object-model role: {{@code {r["role"]}}}.</p>')
+    if r['seq']:
+        L.append('     * <p>Sequence-only: builds a whole sequence — '
+                 'not supported in a streaming context.</p>')
+    L.append('     */')
+    if r['seq']:
+        # sequence-only guard
+        L += [f'    public static {ret} {fname}({args}) {{',
+              '        throw new UnsupportedOperationException(',
+              f'            "{fname} is sequence-only — not supported in a '
+              'streaming context");',
+              '    }', '']
+    else:
+        # runtime MEOS_AVAILABLE guard
+        ret_stmt = '' if ret == 'void' else 'return '
+        L += [f'    public static {ret} {fname}({args}) {{',
+              '        if (!MEOS_AVAILABLE) {',
+              '            throw new UnsupportedOperationException(',
+              f'                "{fname} requires libmeos — set -D{prop}=true");',
+              '        }',
+              f'        {ret_stmt}GeneratedFunctions.{fname}({call_args});',
+              '    }', '']
+    return L
+
+
+def emit_class(cls, rows, pkg, prop, banner):
+    seq_cnt = sum(1 for r in rows if r['seq'])
+    L = [f'package {pkg};', '',
+         '/* AUTO-GENERATED by tools/codegen_jvm.py — do not edit by hand.',
+         f' * {banner}',
+         f' * Methods emitted: {len(rows)} (full jar surface'
+         + (f'; {seq_cnt} sequence-only)' if seq_cnt else ')'),
+         ' * Source: the bundled JMEOS functions.GeneratedFunctions surface,',
+         ' *         grouped by the MEOS-API catalog object model.',
+         ' */', '']
+    L += [f'import {i};' for i in collect_imports(rows)]
+    L += ['',
+          f'public final class {cls} {{', '',
+          '    public static final boolean MEOS_AVAILABLE = '
+          'MeosOpsRuntime.MEOS_AVAILABLE;',
+          '',
+          f'    private {cls}() {{ /* utility */ }}', '']
+    for r in sorted(rows, key=lambda r: r['name']):
+        L += emit_method(r, prop)
+    L.append('}')
+    return '\n'.join(L) + '\n'
+
+
+def runtime_src(pkg, prop):
+    """Shared MEOS_AVAILABLE probe."""
+    return f'''package {pkg};
+
+import functions.GeneratedFunctions;
+
+/* AUTO-GENERATED by tools/codegen_jvm.py — do not edit by hand.
+ * Shared runtime helper: owns the single MEOS_AVAILABLE static-init across all
+ * generated MeosOps* facades, so libmeos is probed exactly once per JVM. */
+final class MeosOpsRuntime {{
+
+    static final boolean MEOS_AVAILABLE;
+
+    static {{
+        boolean enabled = Boolean.parseBoolean(
+                System.getProperty("{prop}", "true"));
+        boolean ok = false;
+        if (enabled) {{
+            try {{
+                GeneratedFunctions.meos_initialize();
+                ok = true;
+            }} catch (Throwable t) {{
+                ok = false;
+            }}
+        }}
+        MEOS_AVAILABLE = ok;
+    }}
+
+    private MeosOpsRuntime() {{ /* utility */ }}
+}}
+'''
+
+
+def run_facades(args):
+    prop = f'mobility{args.engine}.meos.enabled'
+    out_dir = Path(args.out) / 'src/main/java' / args.package.replace('.', '/')
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    cat = load_catalog(args.catalog)
+    jmeos = parse_jmeos_signatures(args.jar)
+    fn_class, fn_role, fn_header, fn_seq = object_model_index(cat)
+
+    # FULL surface: one row per jar symbol (the jar is the ground truth of what the
+    # bundled JMEOS actually exposes). A jar symbol absent from the catalog has no
+    # class/header, so it falls back to the core free class and the return-type
+    # sequence check.
+    rows = []
+    for name, sig in jmeos.items():
+        rows.append({
+            'name': name,
+            'java_ret': sig['ret'],
+            'java_params': [(t, f'arg{i}') for i, t in enumerate(sig['arg_types'])],
+            'oo_class': fn_class.get(name),
+            'role': fn_role.get(name),
+            'header': fn_header.get(name, 'meos.h'),
+            'seq': fn_seq.get(name, seq_typed(sig['ret'])),
+        })
+
+    # Regenerate from scratch: drop stale MeosOps*.java, keep hand-written caller
+    # logic in the same package (e.g. MeosSetSetJoin.java).
+    for f in out_dir.glob('MeosOps*.java'):
+        f.unlink()
+    (out_dir / 'MeosOpsRuntime.java').write_text(runtime_src(args.package, prop))
+
+    # Group by the FINAL class name, not the raw grouping key: several distinct
+    # headers collapse to the same free class (e.g. cbuffer.h and meos_cbuffer.h
+    # both -> MeosOpsFreeCbuffer), so key on the class name and MERGE their rows —
+    # else the second write_text would clobber the first and silently drop methods.
+    by_class = defaultdict(list)      # class name -> rows
+    class_headers = defaultdict(set)  # free class name -> contributing headers
+    for r in rows:
+        if r['oo_class']:
+            by_class[f'MeosOps{r["oo_class"]}'].append(r)
+        else:
+            cls = header_to_class(r['header'])
+            by_class[cls].append(r)
+            class_headers[cls].add(r['header'])
+
+    for cls, crows in sorted(by_class.items()):
+        if cls in class_headers:
+            banner = 'Free functions from ' + ', '.join(sorted(class_headers[cls]))
+        else:
+            banner = 'MEOS object-model class: ' + cls[len('MeosOps'):]
+        (out_dir / f'{cls}.java').write_text(
+            emit_class(cls, crows, args.package, prop, banner))
+
+    n_seq = sum(1 for r in rows if r['seq'])
+    n_oo = sum(1 for c in by_class if c not in class_headers)
+    n_free = len(class_headers)
+    print(f'{args.engine}: emitted {1 + len(by_class)} facade classes into {out_dir} '
+          f'({n_oo} object-model + {n_free} free + MeosOpsRuntime), '
+          f'{len(rows)} methods ({n_seq} sequence-only guarded)')
+
+
+# ───────────────────────── entry point ─────────────────────────
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument('--engine', required=True, choices=['spark', 'flink', 'kafka'])
+    ap.add_argument('--catalog', required=True, help='MEOS-API meos-idl.json')
+    ap.add_argument('--jar', required=True,
+                    help='JMEOS jar with functions.GeneratedFunctions')
+    ap.add_argument('--out', required=True, help='output directory')
+    ap.add_argument('--package', default='org.mobilitydb.meos',
+                    help='facade package (flink/kafka only)')
+    ap.add_argument('--report', action='store_true', help='spark only')
+    args = ap.parse_args()
+
+    if args.engine == 'spark':
+        run_spark(args)
+    else:
+        run_facades(args)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/regen_baseline.sh b/tools/regen_baseline.sh
deleted file mode 100755
index 522cb7e..0000000
--- a/tools/regen_baseline.sh
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-# Regenerate tools/baseline/streaming-relevance-baseline.json — the generator
-# input consumed by codegen_facades.py.
-#
-# The baseline is a deterministic classification of the MEOS public API into
-# streaming tiers. It is derived from the MEOS-API catalog (meos-idl.json),
-# which is itself produced by running MEOS-API/run.py over the MEOS headers at
-# the commit recorded in tools/meos-source-commit.txt. See GENERATION.md.
-#
-# Usage:
-#   tools/regen_baseline.sh <meos-idl.json> [source-ref]
-#
-#   <meos-idl.json>  the MEOS-API catalog (from MEOS-API/run.py over the MEOS
-#                    headers at tools/meos-source-commit.txt)
-#   [source-ref]     optional portable provenance label recorded in the artifact
-#
-# The classifier is deterministic: the same catalog always yields the same
-# baseline, so a refresh is: rebuild the catalog at the tracked commit, re-run
-# this script, commit the diff.
-set -euo pipefail
-
-here="$(cd "$(dirname "$0")" && pwd)"
-catalog="${1:?usage: regen_baseline.sh <meos-idl.json> [source-ref]}"
-source_ref="${2:-meos-idl.json (MEOS-API run.py over tools/meos-source-commit.txt)}"
-out="$here/baseline/streaming-relevance-baseline.json"
-
-# The baseline is a derived, gitignored build artifact, so its directory is absent
-# in a fresh checkout — create it before the classifier writes.
-mkdir -p "$here/baseline"
-
-python3 "$here/classify_streaming_relevance.py" "$catalog" \
-  --source-ref "$source_ref" -o "$out"
-
-echo "regenerated $out"