java-codebase-rag 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

build_ast_graph.py

@@ -39,6 +39,7 @@ from dataclasses import asdict, dataclass, field, replace
 from pathlib import Path
 
 import ladybug
+import pyarrow as pa
 
 from ast_java import (
     ONTOLOGY_VERSION,
@@ -187,6 +188,12 @@ class TypeIndexEntry:
     package: str
     outer_fqn: str | None
     node_id: str
+    # True when this entry was loaded from the existing graph by
+    # `_load_existing_types` (an unchanged-file stub used only for cross-file
+    # resolution). Its `decl` is a placeholder (no annotations/methods), so its
+    # recomputed role/capabilities must never be written back over the real
+    # stored values. See `_write_nodes_impl`.
+    loaded_from_db: bool = False
 
 
 @dataclass
@@ -199,6 +206,11 @@ class MemberEntry:
     module: str
     microservice: str
     node_id: str
+    # True when loaded from the existing graph by `_load_existing_members`
+    # (an unchanged-file stub used only for cross-file call resolution). Its
+    # DECLARES edge already persists in the graph, so it must not be re-emitted
+    # by `_populate_declares_rows` (REL tables have no PK → would duplicate).
+    loaded_from_db: bool = False
 
 
 @dataclass
@@ -555,7 +567,7 @@ def _load_existing_types(conn: ladybug.Connection, tables: GraphTables, exclude_
     if exclude_files is not None and not exclude_files:
         return
 
-    where = "WHERE s.kind IN ['class', 'interface', 'enum', 'annotation', 'record']"
+    where = f"WHERE s.kind IN {list(_TYPE_KINDS)}"
     params: dict = {}
     if exclude_files:
         where += "\n    AND NOT (s.filename IN $exclude_files)"
@@ -585,6 +597,7 @@ def _load_existing_types(conn: ladybug.Connection, tables: GraphTables, exclude_
             package=package,
             outer_fqn=None,
             node_id=node_id,
+            loaded_from_db=True,
         )
         tables.types[fqn] = entry
         tables.by_simple_name.setdefault(name, []).append(entry)
@@ -633,6 +646,7 @@ def _load_existing_members(conn: ladybug.Connection, tables: GraphTables, exclud
             module="",
             microservice="",
             node_id=node_id,
+            loaded_from_db=True,
         ))
 
 
@@ -670,6 +684,54 @@ def _find_dependents(conn: ladybug.Connection, changed_node_ids: set[str]) -> se
     return dependent_files
 
 
+def _find_annotation_dependents(conn: ladybug.Connection, changed_node_ids: set[str]) -> set[str]:
+    """Find files that USE an annotation whose DEFINITION is among the changed nodes.
+
+    Annotation usage is a node property (``annotations`` STRING[]), not a
+    Symbol->Symbol edge, so `_find_dependents` — which walks edges — never pulls
+    annotation users into scope. When an annotation definition changes (e.g.
+    ``@interface Foo`` gains a meta-annotation that shifts the Layer-A chain in
+    `resolve_role_and_capabilities`), every type carrying ``@Foo`` may need its
+    ``role``/``capabilities`` recomputed or it goes stale until the next full
+    rebuild. Return those users' files so the orchestrator treats them as
+    dependents (re-parsed, role re-SET); the expansion cap bounds the scope.
+
+    Scope is direct usage only: a user of an annotation that transitively
+    composes the changed one (e.g. ``@A`` where ``@A`` is meta-annotated with the
+    changed ``@B``) is NOT pulled in — that reverse-chain walk is left to a
+    future hardening pass. The direct case covers the dominant real-world shape
+    (a stereotype annotation applied directly to many types).
+    """
+    if not changed_node_ids:
+        return set()
+    # Changed annotation definitions → the simple names users reference them by.
+    # Runs before `_delete_file_scope`, so the def nodes still exist.
+    name_result = conn.execute(
+        "MATCH (s:Symbol) WHERE s.id IN $ids AND s.kind = 'annotation' RETURN s.name",
+        {"ids": list(changed_node_ids)},
+    )
+    names: list[str] = []
+    while name_result.has_next():
+        nm = name_result.get_next()[0]
+        if nm:
+            names.append(nm)
+    if not names:
+        return set()
+    dependent_files: set[str] = set()
+    for nm in names:
+        user_result = conn.execute(
+            "MATCH (s:Symbol) "
+            "WHERE list_contains(s.annotations, $nm) AND s.filename <> '' "
+            "RETURN DISTINCT s.filename",
+            {"nm": nm},
+        )
+        while user_result.has_next():
+            fn = user_result.get_next()[0]
+            if fn:
+                dependent_files.add(fn)
+    return dependent_files
+
+
 def _delete_file_scope(
     conn: ladybug.Connection,
     changed_files: set[str],
@@ -821,8 +883,8 @@ def _write_nodes_merge(
     project_root: Path,
     meta_chain: dict[str, frozenset[str]] | None,
 ) -> None:
-    """Write nodes to existing LadybugDB database using MERGE to handle existing nodes."""
-    _write_nodes_impl(conn, tables, project_root=project_root, meta_chain=meta_chain, symbol_query=_MERGE_SYMBOL)
+    """Write nodes to existing LadybugDB database using bulk COPY FROM."""
+    _write_nodes_impl(conn, tables, project_root=project_root, meta_chain=meta_chain)
 
 
 # ---------- file walk (see `path_filtering.iter_java_source_files`) ----------
@@ -2010,8 +2072,21 @@ def _producer_id(
     return f"p:{hashlib.sha1(key.encode()).hexdigest()[:16]}"
 
 
+# The four brownfield source layers — single source of truth. Consumed by the
+# client/producer source-layer classifiers, the *_from_brownfield_pct stats
+# (via brownfield_strategies), and the brownfield_only authoritativeness gate in
+# _is_brownfield_sourced. codebase_client/codebase_producer are caller-side
+# declaration strategies, not layers — they extend brownfield_strategies only.
+_BROWNFIELD_LAYERS = frozenset({
+    "layer_a_meta",
+    "layer_b_ann",
+    "layer_b_fqn",
+    "layer_c_source",
+})
+
+
 def _client_source_layer(strategy: str) -> str:
-    if strategy in {"layer_a_meta", "layer_b_ann", "layer_b_fqn", "layer_c_source"}:
+    if strategy in _BROWNFIELD_LAYERS:
         return strategy
     # Some caller extraction paths emit client kind as strategy; treat those
     # as builtin-source declarations instead of warning on every row.
@@ -2023,7 +2098,7 @@ def _client_source_layer(strategy: str) -> str:
 
 
 def _producer_source_layer(strategy: str) -> str:
-    if strategy in {"layer_a_meta", "layer_b_ann", "layer_b_fqn", "layer_c_source"}:
+    if strategy in _BROWNFIELD_LAYERS:
         return strategy
     if strategy in VALID_PRODUCER_KINDS:
         return "builtin"
@@ -2458,15 +2533,14 @@ def pass5_imperative_edges(
         tables.producer_stats.producers_by_kind = defaultdict(int)
         for row in tables.producer_rows:
             tables.producer_stats.producers_by_kind[row.producer_kind] += 1
-        brownfield_strategies = frozenset(
-            (
-                "layer_b_ann",
-                "layer_a_meta",
-                "layer_c_source",
-                "layer_b_fqn",
-                "codebase_client",
-                "codebase_producer",
-            ),
+        # brownfield_strategies = the four brownfield layers plus the two
+        # caller-side declaration strategies (@CodebaseHttpClient /
+        # @CodebaseProducer). These extend _BROWNFIELD_LAYERS deliberately:
+        # the *_from_brownfield_pct stats count annotation-declared callers as
+        # brownfield-sourced even though they are not "layers" and so do not
+        # gate brownfield_only authoritativeness in _is_brownfield_sourced.
+        brownfield_strategies = _BROWNFIELD_LAYERS | frozenset(
+            {"codebase_client", "codebase_producer"},
         )
         if tables.call_edge_stats.http_calls_total:
             n_http = sum(
@@ -2568,14 +2642,6 @@ def _match_call_edge(
     return "cross_service", candidates
 
 
-_BROWNFIELD_LAYERS = frozenset({
-    "layer_c_source",
-    "layer_b_ann",
-    "layer_b_fqn",
-    "layer_a_meta",
-})
-
-
 def _is_brownfield_sourced(
     call_strategy: str,
     candidates: list[RouteRow],
@@ -3000,27 +3066,112 @@ def _node_row(**kwargs) -> dict:
     return base
 
 
-_CREATE_SYMBOL = (
-    "CREATE (:Symbol {id: $id, kind: $kind, name: $name, fqn: $fqn, "
-    "package: $package, module: $module, microservice: $microservice, "
-    "filename: $filename, "
-    "start_line: $start_line, end_line: $end_line, "
-    "start_byte: $start_byte, end_byte: $end_byte, "
-    "modifiers: $modifiers, annotations: $annotations, capabilities: $capabilities, "
-    "role: $role, signature: $signature, parent_id: $parent_id, resolved: $resolved})"
-)
+def _bulk_copy(conn: ladybug.Connection, table_name: str, columns: list[str], rows: list[dict]) -> None:
+    """Bulk-load rows into a node/rel table via in-memory pyarrow COPY FROM.
+
+    `columns` fixes column order; for REL tables the first two MUST be the
+    FROM/TO node primary keys (kuzu requirement). Empty `rows` is a no-op.
 
-_MERGE_SYMBOL = (
-    "MERGE (n:Symbol {id: $id}) "
+    Spike result (PR-P1 step-1): REL `COPY FROM` expects columns named `FROM` and `TO`
+    for the endpoint node IDs, followed by property columns in the declared order.
+    `pa.Table.from_pylist(rows)` correctly infers types from the dict values, but
+    we must select columns in the exact order expected by the table schema.
+    """
+    if not rows:
+        return
+    tbl = pa.Table.from_pylist(rows)
+    # Select columns in the exact order expected by the table schema
+    tbl = tbl.select(columns)
+    conn.execute(f"COPY {table_name} FROM $rows", {"rows": tbl})
+
+
+def _existing_node_ids(conn: ladybug.Connection) -> set[str]:
+    """Return every node id (Symbol, Route, Client, Producer) currently in the graph.
+
+    Bulk ``COPY FROM`` enforces referential integrity: a REL row whose FROM/TO
+    endpoint isn't a loaded node raises ``Unable to find primary key value``. The
+    legacy per-row ``MERGE (a:Symbol {id:$src}),(b:Symbol {id:$dst})`` silently
+    dropped such edges (a ``MATCH`` against a missing endpoint creates nothing).
+    Edge writers filter edge rows against this set to reproduce that exactly.
+
+    This queries the live DB rather than just ``tables`` because it is shared
+    with the incremental path, whose edges legitimately reference nodes written
+    in prior runs.
+    """
+    result = conn.execute("MATCH (n) RETURN n.id")
+    ids: set[str] = set()
+    while result.has_next():
+        ids.add(result.get_next()[0])
+    return ids
+
+
+# Column-order constants for bulk COPY FROM.
+# For REL tables, the first two entries are FROM/TO node primary keys (kuzu requirement).
+# Order matches the corresponding _SCHEMA_* declarations above.
+_NODE_COLUMNS = [
+    "id", "kind", "name", "fqn", "package", "module", "microservice",
+    "filename", "start_line", "end_line", "start_byte", "end_byte",
+    "modifiers", "annotations", "capabilities", "role", "signature", "parent_id", "resolved"
+]
+
+# Type declaration kinds. Tuple (not set) so the rendered SQL `IN` clause is
+# deterministic. Used to (a) load type stubs for cross-file resolution and
+# (b) scope the incremental property-refresh SET to type nodes.
+_TYPE_KINDS: tuple[str, ...] = ("class", "interface", "enum", "annotation", "record")
+
+# Update every mutable Symbol field on an existing node by primary key. Used on
+# the incremental path to refresh preserved dependent type nodes whose
+# `role`/`capabilities` (and other project-wide-derived fields) can shift
+# without their own source changing — restoring the upsert the legacy per-row
+# `MERGE (n:Symbol {id:$id}) SET …` provided. Field list mirrors `_NODE_COLUMNS`
+# minus `id`.
+_SET_SYMBOL_BY_ID = (
+    "MATCH (n:Symbol {id: $id}) "
     "SET n.kind = $kind, n.name = $name, n.fqn = $fqn, "
     "n.package = $package, n.module = $module, n.microservice = $microservice, "
     "n.filename = $filename, "
     "n.start_line = $start_line, n.end_line = $end_line, "
     "n.start_byte = $start_byte, n.end_byte = $end_byte, "
-    "n.modifiers = $modifiers, n.annotations = $annotations, n.capabilities = $capabilities, "
-    "n.role = $role, n.signature = $signature, n.parent_id = $parent_id, n.resolved = $resolved"
+    "n.modifiers = $modifiers, n.annotations = $annotations, "
+    "n.capabilities = $capabilities, n.role = $role, "
+    "n.signature = $signature, n.parent_id = $parent_id, n.resolved = $resolved"
+)
+
+# Refresh every mutable Route field on an existing Route node by id. Mirrors the
+# `_write_nodes_impl` Symbol pattern (bulk COPY new rows + per-row SET existing
+# ones) so the global pass 5-6 step no longer needs a per-row MERGE upsert.
+# Field list mirrors `_ROUTE_COLUMNS` minus `id`.
+_SET_ROUTE_BY_ID = (
+    "MATCH (r:Route {id: $id}) "
+    "SET r.kind = $kind, r.framework = $framework, r.method = $method, "
+    "r.path = $path, r.path_template = $path_template, r.path_regex = $path_regex, "
+    "r.topic = $topic, r.broker = $broker, r.feign_name = $feign_name, r.feign_url = $feign_url, "
+    "r.microservice = $microservice, r.module = $module, r.filename = $filename, "
+    "r.start_line = $start_line, r.end_line = $end_line, r.resolved = $resolved"
 )
 
+_REL_EXTENDS_COLUMNS = ["FROM", "TO", "source_file", "dst_name", "dst_fqn", "resolved"]
+_REL_IMPLEMENTS_COLUMNS = ["FROM", "TO", "source_file", "dst_name", "dst_fqn", "resolved"]
+_REL_INJECTS_COLUMNS = ["FROM", "TO", "source_file", "dst_name", "dst_fqn", "resolved", "mechanism", "annotation", "field_or_param"]
+_REL_DECLARES_COLUMNS = ["FROM", "TO", "source_file"]
+_REL_OVERRIDES_COLUMNS = ["FROM", "TO", "source_file"]
+_REL_CALLS_COLUMNS = ["FROM", "TO", "source_file", "call_site_line", "call_site_byte", "arg_count", "confidence", "strategy", "source", "resolved", "callee_declaring_role"]
+
+_UNRESOLVED_CALL_SITE_COLUMNS = ["id", "caller_id", "call_site_line", "call_site_byte", "arg_count", "callee_simple", "receiver_expr", "reason"]
+_REL_UNRESOLVED_AT_COLUMNS = ["FROM", "TO", "source_file"]
+
+# Node table column constants (for bulk COPY FROM)
+_ROUTE_COLUMNS = ["id", "kind", "framework", "method", "path", "path_template", "path_regex", "topic", "broker", "feign_name", "feign_url", "microservice", "module", "filename", "start_line", "end_line", "resolved"]
+_CLIENT_COLUMNS = ["id", "client_kind", "target_service", "path", "path_template", "path_regex", "method", "member_fqn", "member_id", "microservice", "module", "filename", "start_line", "end_line", "resolved", "source_layer"]
+_PRODUCER_COLUMNS = ["id", "producer_kind", "topic", "broker", "direction", "member_fqn", "member_id", "microservice", "module", "filename", "start_line", "end_line", "resolved", "source_layer"]
+
+# REL table column constants for routes/clients/producers
+_REL_EXPOSES_COLUMNS = ["FROM", "TO", "source_file", "confidence", "strategy"]
+_REL_DECLARES_CLIENT_COLUMNS = ["FROM", "TO", "source_file", "confidence", "strategy"]
+_REL_DECLARES_PRODUCER_COLUMNS = ["FROM", "TO", "source_file", "confidence", "strategy"]
+_REL_HTTP_CALLS_COLUMNS = ["FROM", "TO", "source_file", "confidence", "strategy", "method_call", "raw_uri", "match"]
+_REL_ASYNC_CALLS_COLUMNS = ["FROM", "TO", "source_file", "confidence", "strategy", "direction", "raw_topic", "match"]
+
 
 def _write_nodes_impl(
     conn: ladybug.Connection,
@@ -3028,7 +3179,6 @@ def _write_nodes_impl(
     *,
     project_root: Path,
     meta_chain: dict[str, frozenset[str]] | None,
-    symbol_query: str,
 ) -> None:
     overrides = load_brownfield_overrides(project_root)
     try:
@@ -3037,18 +3187,28 @@ def _write_nodes_impl(
         prs = str(project_root)
     tables.cross_service_resolution = _load_config_cross_service_resolution(prs)
     mch = meta_chain
+
+    # Stage all Symbol rows
+    rows: list[dict] = []
+    # Node ids loaded from the existing graph as resolution-only stubs
+    # (`_load_existing_types`); their staged rows carry placeholder values and
+    # must never be written back over the real nodes.
+    stub_ids: set[str] = set()
+
     # packages
     for pkg, pid in tables.packages.items():
-        conn.execute(symbol_query, _node_row(
+        rows.append(_node_row(
             id=pid, kind="package", name=pkg.rsplit(".", 1)[-1], fqn=pkg, package=pkg,
         ))
     # files
     for path, fid in tables.files.items():
-        conn.execute(symbol_query, _node_row(
+        rows.append(_node_row(
             id=fid, kind="file", name=Path(path).name, fqn=path, filename=path,
         ))
     # types
     for entry in tables.types.values():
+        if entry.loaded_from_db:
+            stub_ids.add(entry.node_id)
         d = entry.decl
         role, capabilities = resolve_role_and_capabilities(
             d,
@@ -3056,7 +3216,7 @@ def _write_nodes_impl(
             meta_chain=mch,
         )
         tables.type_role_by_node_id[entry.node_id] = role
-        conn.execute(symbol_query, _node_row(
+        rows.append(_node_row(
             id=entry.node_id, kind=d.kind, name=d.name, fqn=d.fqn,
             package=entry.package,
             module=entry.module, microservice=entry.microservice,
@@ -3072,7 +3232,7 @@ def _write_nodes_impl(
         ))
     # members (methods / constructors)
     for m in tables.members:
-        conn.execute(symbol_query, _node_row(
+        rows.append(_node_row(
             id=m.node_id, kind=m.kind, name=m.decl.name,
             fqn=f"{m.parent_fqn}#{m.decl.signature}",
             package=tables.types[m.parent_fqn].package if m.parent_fqn in tables.types else "",
@@ -3086,7 +3246,35 @@ def _write_nodes_impl(
         ))
     # phantoms
     for pid, row in tables.phantoms.items():
-        conn.execute(symbol_query, row)
+        rows.append(row)
+
+    # Bulk-load new Symbol rows. The full-rebuild path starts from an empty
+    # database (`_drop_all`), so every row is new. The incremental path reaches
+    # here with a populated database: changed-file nodes were deleted by
+    # `_delete_file_scope` (absent here → new), while dependent-file nodes are
+    # deliberately preserved (see `_delete_file_scope` / issue #305).
+    existing_ids = _existing_node_ids(conn)
+    new_rows = [row for row in rows if row["id"] not in existing_ids]
+    _bulk_copy(conn, "Symbol", _NODE_COLUMNS, new_rows)
+
+    # Refresh mutable properties on preserved dependent TYPE nodes (incremental
+    # path only; `update_rows` is empty on the full path). `role`/`capabilities`
+    # — and any other field derived from project-wide inputs (meta-annotation
+    # chain, brownfield overrides) — can shift without the type's own source
+    # changing, so a preserved dependent must be re-SET to stay byte-equivalent
+    # with a full rebuild. The legacy per-row `_MERGE_SYMBOL` upserted every
+    # staged node and did this implicitly; bulk `COPY FROM` only appends, so the
+    # SET is explicit here. Stubs (`stub_ids`) are skipped: their decl is a
+    # placeholder and their stored values are authoritative. Non-type kinds
+    # carry no mutable role/capabilities, so they are skipped too.
+    update_rows = [
+        row for row in rows
+        if row["id"] in existing_ids
+        and row["id"] not in stub_ids
+        and row["kind"] in _TYPE_KINDS
+    ]
+    for row in update_rows:
+        conn.execute(_SET_SYMBOL_BY_ID, row)
 
 
 def _write_nodes(
@@ -3096,95 +3284,21 @@ def _write_nodes(
     project_root: Path,
     meta_chain: dict[str, frozenset[str]] | None,
 ) -> None:
-    _write_nodes_impl(conn, tables, project_root=project_root, meta_chain=meta_chain, symbol_query=_CREATE_SYMBOL)
+    _write_nodes_impl(conn, tables, project_root=project_root, meta_chain=meta_chain)
 
 
-_CREATE_EXT = (
-    "MATCH (a:Symbol {id: $src}), (b:Symbol {id: $dst}) "
-    "CREATE (a)-[:EXTENDS {source_file: $source_file, dst_name: $dst_name, dst_fqn: $dst_fqn, resolved: $resolved}]->(b)"
-)
-_CREATE_IMPL = (
-    "MATCH (a:Symbol {id: $src}), (b:Symbol {id: $dst}) "
-    "CREATE (a)-[:IMPLEMENTS {source_file: $source_file, dst_name: $dst_name, dst_fqn: $dst_fqn, resolved: $resolved}]->(b)"
-)
-_CREATE_INJ = (
-    "MATCH (a:Symbol {id: $src}), (b:Symbol {id: $dst}) "
-    "CREATE (a)-[:INJECTS {source_file: $source_file, dst_name: $dst_name, dst_fqn: $dst_fqn, resolved: $resolved, "
-    "mechanism: $mechanism, annotation: $annotation, field_or_param: $field_or_param}]->(b)"
-)
-_CREATE_DECL = (
-    "MATCH (a:Symbol {id: $src}), (b:Symbol {id: $dst}) "
-    "CREATE (a)-[:DECLARES {source_file: $source_file}]->(b)"
-)
-_CREATE_OVERRIDES = (
-    "MATCH (a:Symbol {id: $src}), (b:Symbol {id: $dst}) "
-    "CREATE (a)-[:OVERRIDES {source_file: $source_file}]->(b)"
-)
-_CREATE_CALL = (
-    "MATCH (a:Symbol {id: $src}), (b:Symbol {id: $dst}) "
-    "CREATE (a)-[:CALLS {"
-    "source_file: $source_file, "
-    "call_site_line: $line, call_site_byte: $byte, arg_count: $argc, "
-    "confidence: $conf, strategy: $strat, source: $src_kind, resolved: $resolved, "
-    "callee_declaring_role: $callee_declaring_role"
-    "}]->(b)"
-)
-
-_CREATE_ROUTE = (
-    "CREATE (:Route {"
-    "id: $id, kind: $kind, framework: $framework, method: $method, "
-    "path: $path, path_template: $path_template, path_regex: $path_regex, "
-    "topic: $topic, broker: $broker, feign_name: $feign_name, feign_url: $feign_url, "
-    "microservice: $microservice, module: $module, filename: $filename, "
-    "start_line: $start_line, end_line: $end_line, resolved: $resolved"
-    "})"
-)
-_CREATE_CLIENT = (
-    "CREATE (:Client {"
-    "id: $id, client_kind: $client_kind, target_service: $target_service, "
-    "path: $path, path_template: $path_template, path_regex: $path_regex, method: $method, "
-    "member_fqn: $member_fqn, member_id: $member_id, "
-    "microservice: $microservice, module: $module, filename: $filename, "
-    "start_line: $start_line, end_line: $end_line, resolved: $resolved, source_layer: $source_layer"
-    "})"
-)
-
-_CREATE_EXPOSES = (
-    "MATCH (s:Symbol {id: $sid}), (r:Route {id: $rid}) "
-    "CREATE (s)-[:EXPOSES {source_file: $source_file, confidence: $confidence, strategy: $strategy}]->(r)"
-)
-_CREATE_DECLARES_CLIENT = (
-    "MATCH (s:Symbol {id: $sid}), (c:Client {id: $cid}) "
-    "CREATE (s)-[:DECLARES_CLIENT {source_file: $source_file, confidence: $confidence, strategy: $strategy}]->(c)"
-)
-_CREATE_PRODUCER = (
-    "CREATE (:Producer {"
-    "id: $id, producer_kind: $producer_kind, topic: $topic, broker: $broker, "
-    "direction: $direction, member_fqn: $member_fqn, member_id: $member_id, "
-    "microservice: $microservice, module: $module, filename: $filename, "
-    "start_line: $start_line, end_line: $end_line, resolved: $resolved, "
-    "source_layer: $source_layer"
-    "})"
-)
-_CREATE_DECLARES_PRODUCER = (
-    "MATCH (s:Symbol {id: $sid}), (p:Producer {id: $pid}) "
-    "CREATE (s)-[:DECLARES_PRODUCER {source_file: $source_file, confidence: $confidence, strategy: $strategy}]->(p)"
-)
-_CREATE_HTTP_CALL = (
-    "MATCH (c:Client {id: $cid}), (r:Route {id: $rid}) "
-    "CREATE (c)-[:HTTP_CALLS {source_file: $source_file, confidence: $confidence, strategy: $strategy, "
-    "method_call: $method_call, raw_uri: $raw_uri, match: $match}]->(r)"
-)
-_CREATE_ASYNC_CALL = (
-    "MATCH (p:Producer {id: $pid}), (r:Route {id: $rid}) "
-    "CREATE (p)-[:ASYNC_CALLS {source_file: $source_file, confidence: $confidence, strategy: $strategy, "
-    "direction: $direction, raw_topic: $raw_topic, match: $match}]->(r)"
-)
 
 
 def _populate_declares_rows(tables: GraphTables) -> None:
+    # Skip members loaded from the existing graph for cross-file resolution: a
+    # DECLARES edge for an unchanged-file member already persists (its
+    # source_file is out of scope, so `_delete_file_scope` left it), and
+    # re-emitting it would append a duplicate (REL tables carry no primary key).
+    # Full-rebuild never loads members, so this is a no-op there.
     tables.declares_rows = [
-        DeclaresRow(src_id=m.parent_id, dst_id=m.node_id) for m in tables.members
+        DeclaresRow(src_id=m.parent_id, dst_id=m.node_id)
+        for m in tables.members
+        if not m.loaded_from_db
     ]
 
 
@@ -3242,93 +3356,126 @@ def _write_edges(conn: ladybug.Connection, tables: GraphTables, _file_by_node_id
     if _file_by_node_id is None:
         _file_by_node_id = _build_file_by_node_id(tables)
 
-    for r in tables.extends_rows:
-        conn.execute(_CREATE_EXT, {
-            "src": r.src_id, "dst": r.dst_id,
+    # Bulk COPY FROM enforces referential integrity — a REL row whose endpoint
+    # node isn't loaded raises "Unable to find primary key value". The legacy
+    # per-row MERGE silently skipped such edges; drop them here to preserve the
+    # per-row graph exactly. _existing_node_ids reads the live DB (not just
+    # `tables`) so the incremental path's references to prior-run nodes still hold.
+    valid_ids = _existing_node_ids(conn)
+
+    # Stage EXTENDS rows
+    extends_rows = [
+        {
+            "FROM": r.src_id, "TO": r.dst_id,
             "source_file": _file_by_node_id.get(r.src_id, ""),
             "dst_name": r.dst_name, "dst_fqn": r.dst_fqn, "resolved": r.resolved,
-        })
-    for r in tables.implements_rows:
-        conn.execute(_CREATE_IMPL, {
-            "src": r.src_id, "dst": r.dst_id,
+        }
+        for r in tables.extends_rows
+        if r.src_id in valid_ids and r.dst_id in valid_ids
+    ]
+    _bulk_copy(conn, "EXTENDS", _REL_EXTENDS_COLUMNS, extends_rows)
+
+    # Stage IMPLEMENTS rows
+    implements_rows = [
+        {
+            "FROM": r.src_id, "TO": r.dst_id,
             "source_file": _file_by_node_id.get(r.src_id, ""),
             "dst_name": r.dst_name, "dst_fqn": r.dst_fqn, "resolved": r.resolved,
-        })
-    for r in tables.injects_rows:
-        conn.execute(_CREATE_INJ, {
-            "src": r.src_id, "dst": r.dst_id,
+        }
+        for r in tables.implements_rows
+        if r.src_id in valid_ids and r.dst_id in valid_ids
+    ]
+    _bulk_copy(conn, "IMPLEMENTS", _REL_IMPLEMENTS_COLUMNS, implements_rows)
+
+    # Stage INJECTS rows
+    injects_rows = [
+        {
+            "FROM": r.src_id, "TO": r.dst_id,
             "source_file": _file_by_node_id.get(r.src_id, ""),
             "dst_name": r.dst_name, "dst_fqn": r.dst_fqn, "resolved": r.resolved,
             "mechanism": r.mechanism, "annotation": r.annotation,
             "field_or_param": r.field_or_param,
-        })
+        }
+        for r in tables.injects_rows
+        if r.src_id in valid_ids and r.dst_id in valid_ids
+    ]
+    _bulk_copy(conn, "INJECTS", _REL_INJECTS_COLUMNS, injects_rows)
 
-    for row in tables.declares_rows:
-        conn.execute(_CREATE_DECL, {
-            "src": row.src_id, "dst": row.dst_id,
+    # Stage DECLARES rows
+    declares_rows = [
+        {
+            "FROM": row.src_id, "TO": row.dst_id,
             "source_file": _file_by_node_id.get(row.src_id, ""),
-        })
+        }
+        for row in tables.declares_rows
+        if row.src_id in valid_ids and row.dst_id in valid_ids
+    ]
+    _bulk_copy(conn, "DECLARES", _REL_DECLARES_COLUMNS, declares_rows)
 
-    for row in tables.overrides_rows:
-        conn.execute(_CREATE_OVERRIDES, {
-            "src": row.src_id, "dst": row.dst_id,
+    # Stage OVERRIDES rows
+    overrides_rows = [
+        {
+            "FROM": row.src_id, "TO": row.dst_id,
             "source_file": _file_by_node_id.get(row.src_id, ""),
-        })
+        }
+        for row in tables.overrides_rows
+        if row.src_id in valid_ids and row.dst_id in valid_ids
+    ]
+    _bulk_copy(conn, "OVERRIDES", _REL_OVERRIDES_COLUMNS, overrides_rows)
 
+    # Stage CALLS rows with dedup and callee_declaring_role materialization
     seen_calls: set[tuple[str, str, int, int]] = set()
-    unique_calls: list[CallsRow] = []
+    calls_rows: list[dict] = []
+    member_by_id = {m.node_id: m for m in tables.members}
     for row in tables.calls_rows:
+        if row.src_id not in valid_ids or row.dst_id not in valid_ids:
+            continue
         key = (row.src_id, row.dst_id, row.arg_count, row.call_site_line)
-        if key not in seen_calls:
-            seen_calls.add(key)
-            unique_calls.append(row)
-
-    member_by_id = {m.node_id: m for m in tables.members}
-    for row in unique_calls:
-        conn.execute(_CREATE_CALL, {
-            "src": row.src_id, "dst": row.dst_id,
+        if key in seen_calls:
+            continue
+        seen_calls.add(key)
+        calls_rows.append({
+            "FROM": row.src_id, "TO": row.dst_id,
             "source_file": _file_by_node_id.get(row.src_id, ""),
-            "line": row.call_site_line,
-            "byte": row.call_site_byte,
-            "argc": row.arg_count,
-            "conf": row.confidence,
-            "strat": row.strategy,
-            "src_kind": row.source,
-            "resolved": row.resolved,
+            "call_site_line": row.call_site_line, "call_site_byte": row.call_site_byte,
+            "arg_count": row.arg_count, "confidence": row.confidence, "strategy": row.strategy,
+            "source": row.source, "resolved": row.resolved,
             "callee_declaring_role": _callee_declaring_role_at_write(
                 tables, row.dst_id, member_by_id=member_by_id,
             ),
         })
+    _bulk_copy(conn, "CALLS", _REL_CALLS_COLUMNS, calls_rows)
 
-    _CREATE_UNRESOLVED = (
-        "CREATE (:UnresolvedCallSite {"
-        "id: $id, caller_id: $caller_id, call_site_line: $line, call_site_byte: $byte, "
-        "arg_count: $argc, callee_simple: $callee, receiver_expr: $recv, reason: $reason"
-        "})"
-    )
-    _CREATE_UNRESOLVED_AT = (
-        "MATCH (a:Symbol {id: $caller}), (u:UnresolvedCallSite {id: $ucs}) "
-        "CREATE (a)-[:UNRESOLVED_AT {source_file: $source_file}]->(u)"
-    )
+    # Stage UnresolvedCallSite node rows (must load before UNRESOLVED_AT edges)
     seen_ucs: set[str] = set()
+    ucs_rows: list[dict] = []
     for row in tables.unresolved_call_site_rows:
         if row.id in seen_ucs:
             continue
         seen_ucs.add(row.id)
-        conn.execute(_CREATE_UNRESOLVED, {
+        ucs_rows.append({
             "id": row.id,
             "caller_id": row.caller_id,
-            "line": row.call_site_line,
-            "byte": row.call_site_byte,
-            "argc": row.arg_count,
-            "callee": row.callee_simple,
-            "recv": row.receiver_expr,
+            "call_site_line": row.call_site_line,
+            "call_site_byte": row.call_site_byte,
+            "arg_count": row.arg_count,
+            "callee_simple": row.callee_simple,
+            "receiver_expr": row.receiver_expr,
             "reason": row.reason,
         })
-        conn.execute(_CREATE_UNRESOLVED_AT, {
-            "caller": row.caller_id, "ucs": row.id,
-            "source_file": _file_by_node_id.get(row.caller_id, ""),
-        })
+    _bulk_copy(conn, "UnresolvedCallSite", _UNRESOLVED_CALL_SITE_COLUMNS, ucs_rows)
+
+    # Stage UNRESOLVED_AT edge rows (one per unique UnresolvedCallSite node)
+    # Use the same ucs_rows list to ensure 1:1 correspondence
+    unresolved_at_rows = [
+        {
+            "FROM": ucs_row["caller_id"], "TO": ucs_row["id"],
+            "source_file": _file_by_node_id.get(ucs_row["caller_id"], ""),
+        }
+        for ucs_row in ucs_rows
+        if ucs_row["caller_id"] in valid_ids
+    ]
+    _bulk_copy(conn, "UNRESOLVED_AT", _REL_UNRESOLVED_AT_COLUMNS, unresolved_at_rows)
 
 
 def _write_routes_and_exposes(conn: ladybug.Connection, tables: GraphTables, _file_by_node_id: dict[str, str] | None = None) -> None:
@@ -3342,8 +3489,12 @@ def _write_routes_and_exposes(conn: ladybug.Connection, tables: GraphTables, _fi
     # Build producer_id -> filename lookup for ASYNC_CALLS source_file.
     _file_by_producer_id: dict[str, str] = {row.id: row.filename for row in tables.producer_rows}
 
-    for row in tables.routes_rows:
-        conn.execute(_CREATE_ROUTE, {
+    # Bulk COPY FROM enforces referential integrity — get all valid node IDs
+    valid_ids = _existing_node_ids(conn)
+
+    # Stage Route node rows (bulk-load before edges that reference them)
+    route_rows = [
+        {
             "id": row.id,
             "kind": row.kind,
             "framework": row.framework,
@@ -3361,57 +3512,97 @@ def _write_routes_and_exposes(conn: ladybug.Connection, tables: GraphTables, _fi
             "start_line": row.start_line,
             "end_line": row.end_line,
             "resolved": row.resolved,
-        })
-    for row in tables.exposes_rows:
-        conn.execute(_CREATE_EXPOSES, {
-            "sid": row.symbol_id,
-            "rid": row.route_id,
+        }
+        for row in tables.routes_rows
+    ]
+    _bulk_copy(conn, "Route", _ROUTE_COLUMNS, route_rows)
+
+    # Stage Client node rows (bulk-load before edges that reference them)
+    client_rows = [asdict(row) for row in tables.client_rows]
+    _bulk_copy(conn, "Client", _CLIENT_COLUMNS, client_rows)
+
+    # Stage Producer node rows (bulk-load before edges that reference them)
+    producer_rows = [asdict(row) for row in tables.producer_rows]
+    _bulk_copy(conn, "Producer", _PRODUCER_COLUMNS, producer_rows)
+
+    # Re-fetch valid IDs after loading Route/Client/Producer nodes (now includes them)
+    valid_ids = _existing_node_ids(conn)
+
+    # Stage EXPOSES edge rows (Symbol -> Route)
+    exposes_rows = [
+        {
+            "FROM": row.symbol_id,
+            "TO": row.route_id,
             "source_file": _file_by_node_id.get(row.symbol_id, ""),
             "confidence": row.confidence,
             "strategy": row.strategy,
-        })
-    for row in tables.client_rows:
-        conn.execute(_CREATE_CLIENT, asdict(row))
-    for row in tables.declares_client_rows:
-        conn.execute(_CREATE_DECLARES_CLIENT, {
-            "sid": row.symbol_id,
-            "cid": row.client_id,
+        }
+        for row in tables.exposes_rows
+        if row.symbol_id in valid_ids and row.route_id in valid_ids
+    ]
+    _bulk_copy(conn, "EXPOSES", _REL_EXPOSES_COLUMNS, exposes_rows)
+
+    # Stage DECLARES_CLIENT edge rows (Symbol -> Client)
+    declares_client_rows = [
+        {
+            "FROM": row.symbol_id,
+            "TO": row.client_id,
             "source_file": _file_by_node_id.get(row.symbol_id, ""),
             "confidence": row.confidence,
             "strategy": row.strategy,
-        })
-    for row in tables.producer_rows:
-        conn.execute(_CREATE_PRODUCER, asdict(row))
-    for row in tables.declares_producer_rows:
-        conn.execute(_CREATE_DECLARES_PRODUCER, {
-            "sid": row.symbol_id,
-            "pid": row.producer_id,
+        }
+        for row in tables.declares_client_rows
+        if row.symbol_id in valid_ids and row.client_id in valid_ids
+    ]
+    _bulk_copy(conn, "DECLARES_CLIENT", _REL_DECLARES_CLIENT_COLUMNS, declares_client_rows)
+
+    # Stage DECLARES_PRODUCER edge rows (Symbol -> Producer)
+    declares_producer_rows = [
+        {
+            "FROM": row.symbol_id,
+            "TO": row.producer_id,
             "source_file": _file_by_node_id.get(row.symbol_id, ""),
             "confidence": row.confidence,
             "strategy": row.strategy,
-        })
-    for row in tables.http_call_rows:
-        conn.execute(_CREATE_HTTP_CALL, {
-            "cid": row.client_id,
-            "rid": row.route_id,
+        }
+        for row in tables.declares_producer_rows
+        if row.symbol_id in valid_ids and row.producer_id in valid_ids
+    ]
+    _bulk_copy(conn, "DECLARES_PRODUCER", _REL_DECLARES_PRODUCER_COLUMNS, declares_producer_rows)
+
+    # Stage HTTP_CALLS edge rows (Client -> Route)
+    http_call_rows = [
+        {
+            "FROM": row.client_id,
+            "TO": row.route_id,
             "source_file": _file_by_client_id.get(row.client_id, ""),
             "confidence": row.confidence,
             "strategy": row.strategy,
             "method_call": row.method_call,
             "raw_uri": row.raw_uri,
             "match": row.match,
-        })
-    for row in tables.async_call_rows:
-        conn.execute(_CREATE_ASYNC_CALL, {
-            "pid": row.producer_id,
-            "rid": row.route_id,
+        }
+        for row in tables.http_call_rows
+        if row.client_id in valid_ids and row.route_id in valid_ids
+    ]
+    _bulk_copy(conn, "HTTP_CALLS", _REL_HTTP_CALLS_COLUMNS, http_call_rows)
+
+    # Stage ASYNC_CALLS edge rows (Producer -> Route)
+    async_call_rows = [
+        {
+            "FROM": row.producer_id,
+            "TO": row.route_id,
             "source_file": _file_by_producer_id.get(row.producer_id, ""),
             "confidence": row.confidence,
             "strategy": row.strategy,
             "direction": row.direction,
             "raw_topic": row.raw_topic,
             "match": row.match,
-        })
+        }
+        for row in tables.async_call_rows
+        if row.producer_id in valid_ids and row.route_id in valid_ids
+    ]
+    _bulk_copy(conn, "ASYNC_CALLS", _REL_ASYNC_CALLS_COLUMNS, async_call_rows)
 
 
 def _write_meta(conn: ladybug.Connection, tables: GraphTables, source_root: Path) -> None:
@@ -3646,6 +3837,12 @@ def incremental_rebuild(
         # Find dependents
         dependent_files = _find_dependents(conn, changed_node_ids)
 
+        # Annotation-definition change: also pull in files that USE the changed
+        # annotation. Annotation usage is a node property, not a Symbol->Symbol
+        # edge, so `_find_dependents` misses them and their role (derived from
+        # the project-wide meta-chain) would go stale. See PR-P5b.
+        dependent_files |= _find_annotation_dependents(conn, changed_node_ids)
+
         # Union changed files with dependents
         scope_files = changed_files | dependent_files
 
@@ -3810,80 +4007,107 @@ def _write_clients_producers_and_calls(conn: ladybug.Connection, tables: GraphTa
     Route nodes (created by pass5 for cross-service calls) that wouldn't
     otherwise exist in LadybugDB.
     """
-    # Write phantom routes that don't already exist (pass5 creates these for cross-service calls)
-    for row in tables.routes_rows:
-        # MERGE to avoid duplicates with routes written during scoped step
-        conn.execute(
-            "MERGE (r:Route {id: $id}) "
-            "SET r.kind = $kind, r.framework = $framework, r.method = $method, "
-            "r.path = $path, r.path_template = $path_template, r.path_regex = $path_regex, "
-            "r.topic = $topic, r.broker = $broker, r.feign_name = $feign_name, r.feign_url = $feign_url, "
-            "r.microservice = $microservice, r.module = $module, r.filename = $filename, "
-            "r.start_line = $start_line, r.end_line = $end_line, r.resolved = $resolved",
-            asdict(row),
-        )
+    # Bulk-write routes, mirroring `_write_nodes_impl`: COPY the rows that are new
+    # to the DB, and SET every mutable field on the routes already present (the
+    # caller does NOT delete routes, only Clients/Producers — see the global
+    # pass 5-6 block). `tables.routes_rows` is the full route set (pass4 routes +
+    # pass5 phantom routes), not just phantoms, so the SET keeps existing routes'
+    # properties in sync with pass5's cross-service enrichment while the COPY
+    # materializes phantoms that have no node yet. Replaces the last per-row
+    # graph write (MERGE upsert).
+    route_rows = [asdict(row) for row in tables.routes_rows]
+    existing_route_ids = _existing_node_ids(conn)
+    new_route_rows = [r for r in route_rows if r["id"] not in existing_route_ids]
+    _bulk_copy(conn, "Route", _ROUTE_COLUMNS, new_route_rows)
+    for r in route_rows:
+        if r["id"] in existing_route_ids:
+            conn.execute(_SET_ROUTE_BY_ID, r)
 
     # Build node_id lookup for members and types
     member_by_id = {m.node_id: m for m in tables.members}
 
-    # Write clients and producers using asdict (same pattern as _write_routes_and_exposes)
-    for row in tables.client_rows:
-        conn.execute(_CREATE_CLIENT, asdict(row))
-    for row in tables.producer_rows:
-        conn.execute(_CREATE_PRODUCER, asdict(row))
-
+    # Build client_id and producer_id lookups for source_file resolution
     client_by_id = {c.id: c for c in tables.client_rows}
     producer_by_id = {p.id: p for p in tables.producer_rows}
 
-    # Write declares_client edges
-    for row in tables.declares_client_rows:
-        source_file = member_by_id.get(row.symbol_id, MemberEntry(kind="", decl=None, parent_id="", parent_fqn="", file_path="", module="", microservice="", node_id="")).file_path
-        conn.execute(_CREATE_DECLARES_CLIENT, {
-            "sid": row.symbol_id,
-            "cid": row.client_id,
-            "source_file": source_file,
+    # Stage Client + Producer NODE rows unconditionally. The caller DETACH-DELETEs
+    # every Client/Producer node immediately before calling this (see the global
+    # pass 5-6 block), so none are in the DB yet and COPY-ing them fresh is safe.
+    # Do NOT filter node rows against the existing-id set — that is the EDGE filter
+    # pattern mis-applied to nodes, and would drop every node being created (the
+    # caller's delete makes the pre-load set empty by construction).
+    client_rows = [asdict(row) for row in tables.client_rows]
+    _bulk_copy(conn, "Client", _CLIENT_COLUMNS, client_rows)
+    producer_rows = [asdict(row) for row in tables.producer_rows]
+    _bulk_copy(conn, "Producer", _PRODUCER_COLUMNS, producer_rows)
+
+    # Endpoint filtering applies to EDGES only: re-fetch the live node set (now
+    # includes the Clients/Producers just loaded) and drop edge rows whose
+    # endpoints still aren't materialized — reproduces per-row MERGE silent-drop.
+    valid_ids = _existing_node_ids(conn)
+
+    # Stage DECLARES_CLIENT edge rows (Symbol -> Client)
+    # Build source_file lookup from member_by_id
+    declares_client_rows = [
+        {
+            "FROM": row.symbol_id,
+            "TO": row.client_id,
+            "source_file": member_by_id.get(row.symbol_id, MemberEntry(kind="", decl=None, parent_id="", parent_fqn="", file_path="", module="", microservice="", node_id="")).file_path,
             "confidence": row.confidence,
             "strategy": row.strategy,
-        })
+        }
+        for row in tables.declares_client_rows
+        if row.symbol_id in valid_ids and row.client_id in valid_ids
+    ]
+    _bulk_copy(conn, "DECLARES_CLIENT", _REL_DECLARES_CLIENT_COLUMNS, declares_client_rows)
 
-    # Write declares_producer edges
-    for row in tables.declares_producer_rows:
-        source_file = member_by_id.get(row.symbol_id, MemberEntry(kind="", decl=None, parent_id="", parent_fqn="", file_path="", module="", microservice="", node_id="")).file_path
-        conn.execute(_CREATE_DECLARES_PRODUCER, {
-            "sid": row.symbol_id,
-            "pid": row.producer_id,
-            "source_file": source_file,
+    # Stage DECLARES_PRODUCER edge rows (Symbol -> Producer)
+    declares_producer_rows = [
+        {
+            "FROM": row.symbol_id,
+            "TO": row.producer_id,
+            "source_file": member_by_id.get(row.symbol_id, MemberEntry(kind="", decl=None, parent_id="", parent_fqn="", file_path="", module="", microservice="", node_id="")).file_path,
             "confidence": row.confidence,
             "strategy": row.strategy,
-        })
+        }
+        for row in tables.declares_producer_rows
+        if row.symbol_id in valid_ids and row.producer_id in valid_ids
+    ]
+    _bulk_copy(conn, "DECLARES_PRODUCER", _REL_DECLARES_PRODUCER_COLUMNS, declares_producer_rows)
 
-    # Write HTTP_CALLS edges
-    for row in tables.http_call_rows:
-        client = client_by_id.get(row.client_id)
-        conn.execute(_CREATE_HTTP_CALL, {
-            "cid": row.client_id,
-            "rid": row.route_id,
-            "source_file": client.filename if client else "",
+    # Stage HTTP_CALLS edge rows (Client -> Route)
+    http_call_rows = [
+        {
+            "FROM": row.client_id,
+            "TO": row.route_id,
+            "source_file": client_by_id.get(row.client_id, ClientRow(id="", client_kind="", target_service="", path="", path_template="", path_regex="", method="", member_fqn="", member_id="", microservice="", module="", filename="", start_line=0, end_line=0, resolved=False, source_layer="")).filename,
             "confidence": row.confidence,
             "strategy": row.strategy,
             "method_call": row.method_call,
             "raw_uri": row.raw_uri,
             "match": row.match,
-        })
+        }
+        for row in tables.http_call_rows
+        if row.client_id in valid_ids and row.route_id in valid_ids
+    ]
+    _bulk_copy(conn, "HTTP_CALLS", _REL_HTTP_CALLS_COLUMNS, http_call_rows)
 
-    # Write ASYNC_CALLS edges
-    for row in tables.async_call_rows:
-        producer = producer_by_id.get(row.producer_id)
-        conn.execute(_CREATE_ASYNC_CALL, {
-            "pid": row.producer_id,
-            "rid": row.route_id,
-            "source_file": producer.filename if producer else "",
+    # Stage ASYNC_CALLS edge rows (Producer -> Route)
+    async_call_rows = [
+        {
+            "FROM": row.producer_id,
+            "TO": row.route_id,
+            "source_file": producer_by_id.get(row.producer_id, ProducerRow(id="", producer_kind="", topic="", broker="", direction="", member_fqn="", member_id="", microservice="", module="", filename="", start_line=0, end_line=0, resolved=False, source_layer="")).filename,
             "confidence": row.confidence,
             "strategy": row.strategy,
             "direction": row.direction,
             "raw_topic": row.raw_topic,
             "match": row.match,
-        })
+        }
+        for row in tables.async_call_rows
+        if row.producer_id in valid_ids and row.route_id in valid_ids
+    ]
+    _bulk_copy(conn, "ASYNC_CALLS", _REL_ASYNC_CALLS_COLUMNS, async_call_rows)
 
 
 def write_ladybug(