ambitgraph 0.3.0__tar.gz → 0.5.0__tar.gz

{ambitgraph-0.3.0/ambitgraph.egg-info → ambitgraph-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ambitgraph
-Version: 0.3.0
+Version: 0.5.0
 Summary: Read-only codebase scan: reusable units, families, roles, ownership candidates, duplication.
 Author: AmbitGraph
 License: Proprietary

{ambitgraph-0.3.0 → ambitgraph-0.5.0}/ambit_map/export.py

@@ -23,6 +23,10 @@ GRAPH_EXPORT_CAP = 200          # the brief's cap
 EXPORT_INDEX = "index.html"
 EXPORT_MAP = reg.EXPORT_MAP_REL
 EXPORT_LIBRARY = "library.html"
+# The Whole map tab. NOT map.html -- that is the default GRAPH seed page
+# and every existing link plus the manifest resolve to it; renaming it to
+# free the nicer name would break links to fix an aesthetic.
+EXPORT_OVERVIEW = reg.EXPORT_OVERVIEW_REL
 MANIFEST_NAME = "ambitgraph-map.export.json"   # U4 review fix (blocker): the
 # scoped-prune manifest -- lists every relative path THIS export wrote, so
 # the NEXT export deletes only what it itself owns, never a hand-placed file.
@@ -139,6 +143,8 @@ def page_rows(model, dialects):
     # existing link and the manifest resolve to it. A real row now, not a copy.
     rows.append(Row(EXPORT_MAP, "/graph", index_query, 0))
 
+    rows.append(Row(EXPORT_OVERVIEW, "/overview", "", 0))
+
     routes_by_uid = lib._routes_by_uid(dialects)
     units_iter = model.units.values() if hasattr(model, "units") else ()
     order = fam.families_in_use(units_iter, routes_by_uid)

{ambitgraph-0.3.0 → ambitgraph-0.5.0}/ambit_map/graph.py

@@ -1972,3 +1972,76 @@ GRAPH_JS = '''
  box.scrollTop = (H - box.clientHeight) / 2;
 })();
 '''
+
+
+# ---------------------------------------------------------------------------
+# 3.16 THE ISLANDS RENDERER (islands-render wave, 2026-09-05) -- the Whole
+# map tab's drawing half. COMPOSES AND DRAWS ONLY: island_layout.py already
+# decided every position (its own C7); this function's one piece of
+# arithmetic is pack_islands's own documented contract -- every island's
+# placement is normalized into the [0,1] whole-map unit square, so
+# composing means multiplying by a fixed pixel side, never recomputing a
+# bounding box or re-deriving a layout.
+#
+# REUSES the Graph tab's pan/zoom mechanism byte-for-byte: GRAPH_JS (drag
+# to pan, the three zoom buttons, SVG width/height-attribute zoom -- never
+# viewBox alone, the exact trap a design-panel review caught before this
+# was written) and the SAME .cm-canvas/.cm-canvas-wrap/.cm-zoom-ctrl
+# classes/button ids, so the script needs no adaptation. An island node
+# carries no edges (islands.py's own C5), so GRAPH_JS's edge-click/.cm-desc
+# half simply never fires here -- it is not wired to anything, and nothing
+# breaks by its absence (every DOM lookup in GRAPH_JS null-checks first).
+# ---------------------------------------------------------------------------
+
+
+def render_islands_canvas(layout):
+    """The `<div class="cm-canvas-wrap">...` markup for a DRAWABLE
+    product-layout.json payload (the caller decides drawability -- this
+    function assumes `layout["islands"]` is non-empty and never checks)."""
+    side = reg.ISLANDS_CANVAS_SIDE
+    pad = reg.ISLANDS_CANVAS_PADDING
+    w = side + 2 * pad
+    h = w
+
+    boundary_parts = []
+    node_parts = []
+    for isl in layout.get("islands", ()):
+        bx = isl["x"] * side + pad
+        by = isl["y"] * side + pad
+        bs = isl["scale"] * side
+        # A subtle region under the nodes, never a hard border or a label
+        # (design-panel finding: pack_islands shelves islands with zero
+        # gap, so shared placement alone can read as one cluster when it
+        # is two touching ones).
+        boundary_parts.append(
+            '<rect class="isl-island" x="{x}" y="{y}" width="{s}" height="{s}" '
+            'rx="6"></rect>'.format(x=_n(bx), y=_n(by), s=_n(bs)))
+        for node in isl.get("nodes", ()):
+            gx = bx + node["x"] * bs
+            gy = by + node["y"] * bs
+            degree = node.get("d", 0)
+            r = min(reg.ISL_NODE_RADIUS_MAX,
+                    reg.ISL_NODE_RADIUS_MIN + degree * reg.ISL_NODE_RADIUS_PER_DEGREE)
+            node_parts.append(
+                '<a href="{href}"><circle class="isl-node" cx="{cx}" cy="{cy}" '
+                'r="{r}"></circle></a>'.format(
+                    href=reg.href_unit(node["u"]), cx=_n(gx), cy=_n(gy), r=_n(r)))
+
+    svg = (
+        '<svg class="isl-svg" viewBox="0 0 {w} {h}" width="{w}" height="{h}" '
+        'data-zoom="1" role="img" aria-label="{aria}" data-amg-object="islands">'
+        '<g class="isl-islands">{boundaries}</g>'
+        '<g class="isl-nodes">{nodes}</g></svg>'
+    ).format(w=_n(w), h=_n(h), aria=reg.esc(reg.OVERVIEW_CANVAS_LABEL),
+             boundaries="".join(boundary_parts), nodes="".join(node_parts))
+
+    return (
+        '<div class="cm-canvas-wrap"><div class="cm-zoom-ctrl">'
+        '<button type="button" id="cmZoomOut" title="{zo}" aria-label="{zo}">{zog}</button>'
+        '<button type="button" id="cmZoomReset" title="{zr}" aria-label="{zr}">{zrg}</button>'
+        '<button type="button" id="cmZoomIn" title="{zi}" aria-label="{zi}">{zig}</button>'
+        '</div><div class="cm-canvas" data-canvas="1">{svg}</div></div>'
+    ).format(zo=reg.esc(reg.GRAPH_ZOOM_OUT_LABEL), zog=reg.esc(reg.GRAPH_ZOOM_OUT_GLYPH),
+             zr=reg.esc(reg.GRAPH_ZOOM_RESET_LABEL), zrg=reg.esc(reg.GRAPH_ZOOM_RESET_GLYPH),
+             zi=reg.esc(reg.GRAPH_ZOOM_IN_LABEL), zig=reg.esc(reg.GRAPH_ZOOM_IN_GLYPH),
+             svg=svg)

ambitgraph-0.5.0/ambit_map/langmirror.py

@@ -0,0 +1,471 @@
+"""ambit_map/langmirror.py -- the product-side ASSERTED MIRROR of
+ambitgraph/langs.py's declared language vocabulary (R4-DESIGN.md, v2;
+CENSUS.md).
+
+ONE file replacing five scatterings: ambit_map/orchestrate.py's admission
+copy + MAPLLM_EXTRA_INCLUDE_EXT, ambit_map/registry.py's JS_LANGS/PY_LANGS/
+ROUTEDNESS_LANGS, ambit_map/paths.py's KIND_READER_LANGS/_GRAMMAR_EXTS, and
+ambit_map/library.py's own blind-sentence language vocabulary. Every value
+below is UNCHANGED from what its scattered original held -- this module
+only gives them one address; see each field's own comment for its prior
+location, and the module-docstring note below for R4's "no member
+deletion" ruling.
+
+THE WALL (tests/test_import_boundaries.py's violations helper, the
+ambit_map stdlib-only rule inside rule_message, and that file's own
+test_self_test_map_importing_contracts_is_caught test): ambit_map may
+NEVER import ambitgraph, not even ambit_contracts, the house's own
+shared-stdlib-only package -- there was never a choice of a third shared
+package; the wall forecloses it outright (R4-DESIGN.md v2, "The
+architecture ruling"). So this module cannot import ambitgraph/
+langs.py and DERIVE its values the way ambitgraph/symbols.py, edges.py,
+config.py and codelib.py now derive theirs from langs.py -- it is instead
+an ASSERTED COPY: every value below is retyped by hand, checked against
+langs.py's own values ONLY by a TEST (tests/test_langs_mirror_diff.py),
+NEVER by any import at runtime. This is not a new exception -- the
+identical both-sides-import shape is already live at
+tests/test_map_serve.py's own
+test_engine_include_ext_is_duplicated_by_value_and_never_drifts test
+(ENGINE_DEFAULT_INCLUDE_EXT vs ScanConfig().include_ext), which this
+module's own admission field below continues rather than replaces.
+
+Unlike ambitgraph/langs.py (which imports `re` and `dataclasses` for its
+own LangSpec declarations), this module is a pure, dependency-free LEAF:
+no imports at all, not even stdlib. Every value below is a literal, and
+the single function here (`blind_langs`) reads only the table declared
+directly above it, so it needs no import either. Every
+consumer inside this package (orchestrate.py, paths.py, registry.py,
+library.py) imports IT; it imports NONE of them, so no existing consumer
+of registry.py/paths.py/library.py/orchestrate.py risks a cycle by their
+now also depending, transitively, on this module.
+
+NO MEMBER DELETION (R4-DESIGN.md v2, ruling 1, refuting the v1 draft's
+"delete the dead members" plan twice over -- JUDGES-DIGEST.txt LENS 3,
+finding on ruling 1): tests/test_map_registry.py's own
+test_kind_key_maps_import_by_source_language_not_by_kind test already
+pins kind_key("include", "import", "ts") == "include/import.js" --
+deleting "ts" from JS_LANGS reds that live pin. And ambit_map/load.py's
+load_run reads a unit's `lang` value VERBATIM off of symbols.json with NO
+vocabulary gate at all, under this product's own shipped producer-
+portability contract (ambit-mapllm-contract.md, pyproject.toml) -- an
+older or foreign producer's artifact can carry a `lang` this engine's OWN
+current writer (ambitgraph/symbols.py's build_file_plane) never emits
+today. So every grouping below keeps its READER-TOLERANCE members: they
+document what a FILE may say, not only what this engine currently
+writes.
+"""
+
+# ===========================================================================
+# Admission -- CENSUS fact 1. Byte-duplicated from ambitgraph/langs.py's
+# ENGINE_DEFAULT_INCLUDE_EXT, IN ORDER: the order is byte-load-bearing
+# through ambitgraph/symbols.py's config_hash and through the cross-import
+# equality pin at tests/test_map_serve.py's own
+# test_engine_include_ext_is_duplicated_by_value_and_never_drifts test
+# (see that engine module's own docstring for the full argument). Formerly
+# hand-duplicated separately inside ambit_map/orchestrate.py;
+# orchestrate.py now aliases this tuple instead of carrying its own
+# literal.
+# ===========================================================================
+ENGINE_DEFAULT_INCLUDE_EXT = (
+    ".py", ".js", ".ts", ".tsx", ".jsx", ".java", ".jsp", ".jspf",
+    ".css", ".html", ".go", ".rb", ".php", ".cs", ".sql", ".sh",
+    ".c", ".h",
+)
+
+# The extra extensions a mapllm run admits beyond the shared engine default
+# above -- world-popularity order per the founder's list, the C++
+# foundation first (formerly ambit_map/orchestrate.py's own
+# MAPLLM_EXTRA_INCLUDE_EXT literal; this constant is not part of
+# ambitgraph/langs.py at all -- it is this product's OWN scope extension,
+# mirrored here only so orchestrate.py can source every admission fact
+# from this one file). ".c"/".h" left this tuple once they gained a real
+# LangSpec: they are ENGINE_DEFAULT_INCLUDE_EXT members above now, not a
+# mapllm-only widening.
+MAPLLM_EXTRA_INCLUDE_EXT = (".cpp", ".hpp", ".rs")
+
+
+# ===========================================================================
+# Naming's product-side grouping (CENSUS fact 2's third spelling) --
+# formerly ambit_map/registry.py's own JS_LANGS/PY_LANGS literals, the pair
+# kind_key's src_lang branch reads. READER-TOLERANCE VOCABULARY (see module
+# docstring): today ambitgraph/symbols.py's build_file_plane (the only
+# writer of a file row's `lang` field) folds .jsx/.mjs/.cjs/.ts/.tsx all
+# into the single tag "js" -- so "jsx"/"mjs"/"cjs"/"ts"/"tsx" can never
+# appear as a REAL `lang` value THIS engine emits today. They stay in
+# JS_LANGS anyway: an older or foreign producer's symbols.json is free to
+# spell it differently under this product's own producer-portability
+# contract, and ambit_map/load.py's load_run reads `lang` with no
+# vocabulary gate at all. PY_LANGS carries no such extra member -- "py" is
+# the only tag ambitgraph/langs.py's "py" LangSpec ever declares.
+#
+# JAVA_LANGS (Java W1, 2026-09-02, additive): the identical one-tag
+# grouping shape as PY_LANGS -- "java" is the only tag ambitgraph/langs.py's
+# "java" LangSpec ever declares, so this carries no reader-tolerance member
+# either. Exists as its own named grouping (never folded into JS_LANGS or
+# PY_LANGS) because kind_key's import branch needs a THIRD disjoint
+# src_lang bucket once include/import.java joins include/import.py and
+# include/import.js.
+# ===========================================================================
+JS_LANGS = ("js", "jsx", "mjs", "cjs", "ts", "tsx")
+PY_LANGS = ("py",)
+JAVA_LANGS = ("java",)
+# C_LANGS: the identical one-tag grouping shape as PY_LANGS/JAVA_LANGS --
+# "c" is the only tag ambitgraph/langs.py's "c" LangSpec ever declares
+# (its naming_exts {".c", ".h"} both fold to that one tag), so this
+# carries no reader-tolerance member either. Read by kind_key's include
+# branch, which maps a C preprocessor include onto the include/static row
+# (see registry.py's own comment there), and by the unit story's type-kind
+# count gate.
+C_LANGS = ("c",)
+
+# RB_LANGS (Ruby wave 1): the identical one-tag grouping shape as
+# PY_LANGS/JAVA_LANGS/C_LANGS -- "rb" is the only tag ambitgraph/langs.py's
+# "rb" LangSpec ever declares (naming_exts {".rb"}), so this carries no
+# reader-tolerance member either. Read by kind_key's include branch, which
+# maps a resolved `require_relative` onto the include/static row (see
+# registry.py's own comment there), and by the unit story's type-kind
+# count gate.
+RB_LANGS = ("rb",)
+
+# TYPE_SYMBOL_KINDS (Java W1 repair -- the wall-legal PRODUCT-side
+# mirror of ambitgraph/codelib.py's own _TYPE_SYMBOL_KINDS): the literal
+# kind strings symbols.py's own class alternation emits for a Java type
+# declaration ("class"/"interface"/"enum"/"record") -- "constructor" is
+# DELIBERATELY not a member, the same exclusion codelib.py's own set
+# states (a constructor is a member OF a type, never itself a type
+# declaration). Consumed by ambit_map/unitpage.py's own class-count
+# bucket so a Java interface/enum/record renders in the class(es) count
+# on the unit story, not silently in "other named symbol(s)". Diffed
+# against ambitgraph.codelib._TYPE_SYMBOL_KINDS by
+# tests/test_langs_mirror_diff.py (DIFFED_FACT_NAMES entry
+# "type_symbol_kinds") -- one origin (symbols.py's own kind literals), two
+# independently-declared copies, never a cross-wall import.
+TYPE_SYMBOL_KINDS = ("class", "interface", "enum", "record")
+
+# C_TYPE_SYMBOL_KINDS (the wall-legal PRODUCT-side mirror of
+# ambitgraph/codelib.py's own _C_TYPE_SYMBOL_KINDS): the literal kind
+# strings symbols.py's extract_c_symbols emits for a C type declaration --
+# a tagged bodied "struct"/"union"/"enum", and "typedef". "function" is
+# deliberately not a member (it is the callable half, the same boundary
+# TYPE_SYMBOL_KINDS draws against "constructor"). Consumed by
+# ambit_map/unitpage.py's class-count bucket under the C_LANGS gate above:
+# "enum" is a member of BOTH this tuple and TYPE_SYMBOL_KINDS, and the two
+# language gates are disjoint, so a TypeScript enum still renders as
+# "other named symbol(s)" while a C enum counts as a type. Diffed against
+# ambitgraph.codelib._C_TYPE_SYMBOL_KINDS by tests/test_langs_mirror_diff.py
+# (DIFFED_FACT_NAMES entry "c_type_symbol_kinds") -- one origin
+# (symbols.py's own kind literals), two independently-declared copies,
+# never a cross-wall import.
+C_TYPE_SYMBOL_KINDS = ("struct", "union", "enum", "typedef")
+
+# RB_TYPE_SYMBOL_KINDS (Ruby wave 1 -- the wall-legal PRODUCT-side mirror
+# of ambitgraph/codelib.py's own _RB_TYPE_SYMBOL_KINDS): the literal kind
+# strings extract_ruby_symbols emits for a Ruby scope-opener declaration --
+# "class" and "module", the two keywords _RB_SCOPE_LINE_RX matches. Unlike
+# TYPE_SYMBOL_KINDS/C_TYPE_SYMBOL_KINDS above, this set already includes
+# "class" itself (Ruby genuinely has classes), so it feeds BOTH halves of
+# codelib.py's carve identically -- the same shape TYPE_SYMBOL_KINDS takes
+# for Java, never C's shape (which unions "class" in separately because C
+# never emits that literal kind at all). Consumed by
+# ambit_map/unitpage.py's class-count bucket under the RB_LANGS gate
+# above, WIDENING THE COUNT ONLY -- the word stays reg.UNIT_STORY_CLASSES
+# for Ruby (unitpage.py's own class_word ternary is not gated on RB_LANGS
+# at all): Ruby genuinely has classes, so mirroring C's word-swap here
+# would render "N type(s)" about a language whose classes are exactly what
+# the count is naming. Diffed against ambitgraph.codelib._RB_TYPE_SYMBOL_KINDS
+# by tests/test_langs_mirror_diff.py (DIFFED_FACT_NAMES entry
+# "rb_type_symbol_kinds") -- one origin (symbols.py's own kind literals),
+# two independently-declared copies, never a cross-wall import.
+RB_TYPE_SYMBOL_KINDS = ("class", "module")
+
+# NAMESPACE_LANGS (Java W1 repair -- the wall-legal PRODUCT-side mirror of
+# ambitgraph/langs.py's own NAMESPACE_LANGS): the `lang` tags whose units
+# get the java-namespace treatment (the languages whose LangSpec declares
+# namespace=True). Consumed by ambit_map/unitpage.py's class-count bucket
+# as the language gate on TYPE_SYMBOL_KINDS above -- symbols.py emits the
+# SAME literal kinds ("interface"/"enum") for TypeScript declarations,
+# which must keep rendering as "other named symbol(s)", exactly the
+# boundary ambitgraph/codelib.py draws with its own is_java_namespace
+# check at export. Diffed against ambitgraph.langs.NAMESPACE_LANGS by
+# tests/test_langs_mirror_diff.py (DIFFED_FACT_NAMES entry
+# "namespace_langs") -- one origin (the LangSpec namespace flags), two
+# independently-declared copies, never a cross-wall import.
+NAMESPACE_LANGS = frozenset({"java", "jsp"})
+
+
+# ===========================================================================
+# CENSUS fact 8 -- formerly ambit_map/registry.py's own ROUTEDNESS_LANGS
+# literal. READER-TOLERANCE VOCABULARY, same law as JS_LANGS above: "jspf"
+# can never appear as a real `lang` value today (ambitgraph/symbols.py's
+# build_file_plane folds .jspf into the tag "jsp", never into "jspf"
+# itself) but stays for the identical producer-portability reason.
+# Consumed DIRECTLY by ambit_map/library.py's routedness gates
+# (_routedness_is_silent, _blind_for_run) via `langm.ROUTEDNESS_LANGS` --
+# no production call site reads it through registry.py anymore.
+# ambit_map/registry.py still re-exports the name (`ROUTEDNESS_LANGS =
+# langm.ROUTEDNESS_LANGS`), kept alive for backward compatibility and
+# because tests/test_langs_value_pins.py's own R4.0 locked oracle pin
+# still asserts `reg.ROUTEDNESS_LANGS` by value.
+# ===========================================================================
+ROUTEDNESS_LANGS = ("jsp", "jspf", "java")
+
+
+# ===========================================================================
+# CENSUS fact 4's product-side mirror -- formerly ambit_map/paths.py's own
+# KIND_READER_LANGS literal (the full reader-coverage matrix: 19
+# ALLOWED_KINDS rows -> the Unit.lang frozenset each kind's reader covers).
+# Java W1 (2026-09-02): the 19th row, include/import.java, is additive --
+# every pre-existing row's value is UNCHANGED. Values UNCHANGED otherwise;
+# the "why" narrative for each individual row (which real reader function
+# backs it, what its own language gate looks like) stays in
+# ambit_map/paths.py's own module comment beside its KIND_READER_LANGS
+# alias -- this module only carries the literal.
+#
+# _kind_applicable's THREE NAMED DIVERGENCES (ambit_map/paths.py, unmoved
+# -- these are about HOW paths.py USES this table, not part of the table's
+# own values, so the overriding logic and its own inputs (TERMINAL_KINDS,
+# MOUNT_CAPABLE_PACKS) stay declared in paths.py, not here):
+#   1. TERMINAL_KINDS (table/read|write|ddl) -- LANGUAGE-AGNOSTIC by the
+#      real reader's own construction (ambitgraph/tables.py's build_tables
+#      carries no language gate at all): applicable whenever the model
+#      holds any unit at all -- this table's own three TERMINAL rows are
+#      never actually consulted for that decision.
+#   2. "reference/script" -- unconditionally False: CONFIG-gated on
+#      ScanConfig.asset_roots, never language-gated, and this product's own
+#      scan config never sets asset_roots -- so this row's frozenset below
+#      is never actually consulted either; kept only so this dict's key set
+#      still equals paths.ALLOWED_KINDS.
+#   3. "route/mount" -- language overlap against this row IS consulted, but
+#      is NECESSARY, not SUFFICIENT: applicability additionally requires at
+#      least one of MOUNT_CAPABLE_PACKS (express_pack/fastapi_pack/
+#      flask_pack) to have DETECTED this run.
+# ===========================================================================
+KIND_READER_LANGS = {
+    # "c" joins this row rather than opening a twentieth: the C
+    # preprocessor's own `#include` IS a static include -- the target is a
+    # literal read from the source text and never varies at runtime, which
+    # is this row's whole claim -- so registry.kind_key maps a C include
+    # edge here instead of minting a row whose sentence would repeat
+    # include/static's word for word. A C repo's include reader is
+    # therefore named as having run, where a missing member would report
+    # the include plane unmeasured on every C repo forever.
+    # "rb" joins this row the same way (Ruby wave 1): a resolved
+    # `require_relative` IS a static include -- a literal path read from
+    # the source text, spliced in at include time, never varying at
+    # runtime -- the identical claim this row already makes. Without the
+    # member a Ruby repo's 236-edge include lane would report the include
+    # plane unmeasured despite having just drawn every one of them.
+    "include/static": frozenset({"jsp", "c", "rb"}),
+    "include/import.py": frozenset({"py"}),
+    "include/import.js": frozenset({"js"}),
+    # Java W1 (2026-09-02), additive: langs.py's java LangSpec gains
+    # include_lane=True this wave -- the row sits beside its import.py/
+    # import.js siblings, same shape, one reader language.
+    "include/import.java": frozenset({"java"}),
+    "include/require": frozenset({"js"}),
+    "include/dynamic": frozenset({"jsp"}),
+    "include/reexport": frozenset({"js"}),
+    "include/dynamic-import": frozenset({"js"}),
+    "include/member-resolved": frozenset({"js"}),
+    # The Java exact-evidence call tiers (constructor resolution,
+    # static-receiver resolution, static-import binding) record PROVEN
+    # rows into this same "calls" kind: no new kind key, no new lang
+    # tag, no new symbol kind, and no new blind-prose word crosses the
+    # wall for them, so nothing about them enters this mirror or the
+    # DIFFED_FACT_NAMES set. Their twelve coverage keys -- the nine
+    # refusal/correction counters (java_ctor_target_missing,
+    # java_ctor_qualified_unresolved, java_expr_new_refused,
+    # java_static_receiver_undeclared,
+    # java_static_receiver_multisegment, java_static_import_overrides,
+    # java_static_import_target_missing,
+    # java_declaration_window_refused, java_annotation_window_refused)
+    # and the java_call_counter_samples/_files/_samples_omitted
+    # attribution trio -- are engine-side coverage keys with no
+    # product-side reader. A matched-marked calls carrier, if one
+    # ever lands, arrives as its OWN registry kind row and gains its
+    # own entry here beside this one.
+    # "c" joins this row with the C call lane (langs.py's c LangSpec
+    # declares call_lane=True and edges.py builds C its own definer pool):
+    # without the member a C repo would be told the calls reader never
+    # heard of C, the exact defect this table's own NAMESPACE_LANGS
+    # comment records for java.
+    # "rb" joins this row the same way (Ruby wave 1): langs.py's rb
+    # LangSpec declares call_lane=True and edges.py builds Ruby its own
+    # definer pool, landed independently of this stage.
+    "calls": frozenset({"jsp", "java", "py", "js", "c", "rb"}),
+    "reference/script": frozenset({"jsp"}),
+    "route/mount": frozenset({"py", "js"}),
+    "ui/component-use": frozenset({"js"}),
+    "net/fetch-route": frozenset({"js", "py"}),
+    "ui/component-use-matched": frozenset({"js"}),
+    "event/emit": frozenset({"js"}),
+    "table/read": frozenset({"sql", "js", "py", "jsp"}),
+    "table/write": frozenset({"sql", "js", "py", "jsp"}),
+    "table/ddl": frozenset({"sql", "js", "py", "jsp"}),
+}
+
+
+# ===========================================================================
+# CENSUS fact 2's product-side mirror -- formerly ambit_map/paths.py's own
+# _GRAMMAR_EXTS literal, a hand-kept copy of ambitgraph/symbols.py's
+# _LANG_FOR_EXT key set (exactly the extensions with a real comment-
+# blanking grammar). Unlike JS_LANGS/PY_LANGS/ROUTEDNESS_LANGS above, this
+# set carries NO reader-tolerance members: it is a copy of the ENGINE's own
+# key set (every ambitgraph/langs.py LangSpec's naming_exts, unioned), not
+# a copy of a possibly-foreign `lang` value's vocabulary.
+# ===========================================================================
+_GRAMMAR_EXTS = frozenset({
+    ".jsp", ".jspf", ".java", ".js", ".mjs", ".cjs", ".jsx", ".ts", ".tsx",
+    ".py", ".sh", ".sql", ".c", ".h", ".rb",
+})
+
+
+# ===========================================================================
+# CENSUS fact 8's disclosure-gate vocabulary -- THE PER-SENTENCE LANGUAGE
+# TAG, product side. Formerly ambit_map/library.py's own
+# _BLIND_SENTENCE_LANGS/_blind_langs pair; it lives here, with every other
+# cross-wall copy, and library.py aliases the reader.
+#
+# The engine declares each blind sentence's own languages AT the sentence
+# (ambitgraph.symbols.BlindSentence's `langs`, empty meaning the sentence
+# holds for every run). That attribute cannot reach this side of the wall:
+# this package reads a run's ARTIFACT FILES, and json.loads hands back
+# plain strings, so the tag is mirrored here -- the same shape
+# ambit_map/registry.py's CALL_BLIND_MATCH already uses, an opening
+# fragment of one engine sentence held as a stable anchor.
+# tests/test_blind_sentence_langs.py diffs the two declarations entry by
+# entry, in both directions, so a sentence tagged on one side and not the
+# other is red, never a page quietly telling a reader a law about a
+# language it never scanned.
+#
+# Each row is (anchor, langs): the anchor is a fragment no other blind
+# sentence contains, and `langs` is that sentence's own `lang` tags. A
+# sentence no row matches is universal and renders on every run.
+#
+# TWO KINDS OF ANCHOR, one shape. The static sentences
+# (ambitgraph.symbols.BLIND_SENTENCES) are anchored on their opening
+# words. The C include lane's four sentences are built per scan and carry
+# their counts at the END, so each is anchored on the FIXED OPENING PREFIX
+# ambitgraph/edges.py declares beside it -- retyped here by value, exactly
+# as this module retypes every other engine literal, because the wall
+# forbids asking the engine for it. The prefix constants and these rows are
+# held equal by the seam tests, never by an import.
+#
+# The prose-word sniffing this field used to carry (BLIND_LANG_PROSE_WORDS
+# plus library.py's compiled _BLIND_LANG_FILTER) is retired: it was an
+# all-or-nothing guess read off a sentence's English, wrong in both
+# directions (Java-only pages rendering C sentences, C-only pages dropping
+# their own call-coverage note), and the tag rows below are the declared
+# answer that replaces it.
+# ===========================================================================
+_JSP_JAVA = frozenset({"jsp", "jspf", "java"})
+_C = frozenset({"c"})
+# _RB (Ruby wave 1): the identical one-tag alias shape as _C above -- "rb"
+# is the only tag any Ruby-declared sentence ever carries this wave.
+_RB = frozenset({"rb"})
+BLIND_SENTENCE_LANGS = (
+    ("Java declarations inside JSP scriptlet blocks", _JSP_JAVA),
+    ("A Java class whose modifiers are written on their own line", _JSP_JAVA),
+    ("A Java method declared inside an ANONYMOUS class body", _JSP_JAVA),
+    ("A Java annotation-type declaration", _JSP_JAVA),
+    ("A Java declaration with an annotation ANYWHERE on the declaration",
+     _JSP_JAVA),
+    ("In Java, a constructor or static-receiver call can bind", _JSP_JAVA),
+    ("A Java method inherited from a supertype", _JSP_JAVA),
+    ("An anonymous class creation over a Java interface or class", _JSP_JAVA),
+    ("A Java receiver separated from its method call by a line break",
+     _JSP_JAVA),
+    ("Java call and type names under four characters", _JSP_JAVA),
+    ("For Java, three exact-evidence tiers run before the name-match",
+     _JSP_JAVA),
+    # The call-coverage sentence names the C lane beside the JSP/Java one:
+    # a C-only run draws call edges and must keep the note that says how
+    # they were read. Anchor duplicated by value from
+    # ambit_map/registry.py's CALL_BLIND_MATCH (this module imports
+    # nothing, not even its own package's registry, which imports IT).
+    ("call sites are read for the JSP/Java namespace", _JSP_JAVA | _C),
+    # The C declaration grammar's own gaps (ambitgraph.symbols.
+    # BLIND_SENTENCES), anchored on their opening words.
+    ("A C `#define` is never read as a symbol", _C),
+    ("A function that a macro DEFINES is not read at all", _C),
+    ("Conditional and macro-body text is read exactly as written", _C),
+    ("A K&R-style C definition", _C),
+    ("A C definition is read at column 0 and brace depth 0 only", _C),
+    ("A bodied `struct`/`union`/`enum` with no tag", _C),
+    ("Only C definitions are read, never declarations", _C),
+    # The C include lane's four per-scan sentences, anchored on
+    # ambitgraph/edges.py's C_ANGLE_INCLUDE_SENTENCE_PREFIX,
+    # C_QUOTED_UNRESOLVED_SYSTEM_SENTENCE_PREFIX,
+    # C_QUOTED_UNRESOLVED_ABSENT_SENTENCE_PREFIX and
+    # C_QUOTED_UNRESOLVED_SENTENCE_PREFIX, in that order.
+    ("Angle-bracket C includes are never drawn", _C),
+    ("A quoted C include naming a C standard library header", _C),
+    ("A quoted C include with no candidate anywhere in this scan", _C),
+    ("A quoted C include this scan does hold a file for, but position "
+     "does not license,", _C),
+    # Ruby wave 1's own two STATIC, structural gaps (ambitgraph.symbols.
+    # BLIND_SENTENCES), anchored on their opening words -- the same
+    # shape as the C declaration grammar's own gaps just above.
+    ("A Ruby heredoc body, from its opener line", _RB),
+    ("A Ruby percent literal (", _RB),
+    # Ruby wave 1's seven PER-SCAN symbol-grammar sentences
+    # (ambitgraph.symbols.rb_symbol_blind_sentences), anchored on the
+    # fixed prefix constants declared beside that function -- retyped
+    # here by value, exactly as the C include lane's four prefixes are
+    # above.
+    ("A method definition line whose name does not fit any Ruby method "
+     "name shape is refused outright", _RB),
+    ("A method defined directly on one specific runtime object, or a "
+     "singleton class opened on an object other than self, is refused",
+     _RB),
+    ("A private, protected, or module_function marker changes the "
+     "default visibility of every method written after it, a stateful "
+     "effect this wave discloses rather than simulates", _RB),
+    ("An attr_accessor, attr_reader, or attr_writer call defines one or "
+     "more methods by name that this wave does not read as symbols",
+     _RB),
+    ("A define_method, method_missing, class_eval, instance_eval, "
+     "alias, or alias_method call can define or rename a method by a "
+     "name this wave cannot predict", _RB),
+    ("A class, module, or method opener sharing its physical line with "
+     "another statement, separated by a semicolon, is read for its own "
+     "name only", _RB),
+    ("A method definition found indented with no enclosing class, "
+     "module, or singleton scope on the stack sits inside a block "
+     "construct this wave does not track", _RB),
+    # Ruby wave 1's six PER-SCAN edges.py sentences (the include lane's
+    # three, ambitgraph.edges.rb_include_blind_sentences, plus the call
+    # ceiling's three, ambitgraph.edges.rb_call_blind_sentences),
+    # anchored on their own fixed prefix constants, same discipline.
+    ("A require naming a plain load-path string, rather than a "
+     "relative file, searches the Ruby runtime load path and is never "
+     "drawn as an edge", _RB),
+    ("A require_relative naming a file this scan does hold somewhere, "
+     "but not at the position this call computes to, draws no edge",
+     _RB),
+    ("A require_relative naming no file anywhere in this scan draws no "
+     "edge", _RB),
+    ("Ruby calls need neither a receiver nor parentheses, so an EXACT "
+     "count of receiverless, parenless call sites is impossible", _RB),
+    ("A method whose name is a setter or an operator can never be "
+     "reached by either call site shape this lane recognizes", _RB),
+    ("A method name defined in more than one place is dropped from the "
+     "call resolution pool entirely rather than guessed at", _RB),
+)
+
+
+def blind_langs(sentence):
+    """The `lang` tags one blind sentence is about -- the union of every
+    anchor it carries, empty when it names no language at all. Empty is
+    the universal answer, not the unknown one: a sentence this vocabulary
+    does not describe is a sentence about the instrument, true on every
+    run, so it is kept rather than guessed at.
+
+    The one function in this module: it reads only the table right above
+    it and the string handed to it, so it stays as dependency-free as
+    every literal here."""
+    out = set()
+    for anchor, tags in BLIND_SENTENCE_LANGS:
+        if anchor in sentence:
+            out |= tags
+    return frozenset(out)