ambitgraph 0.3.0__tar.gz → 0.4.0__tar.gz

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

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

{ambitgraph-0.3.0 → ambitgraph-0.4.0}/ambit_map/langmirror.py

@@ -5,7 +5,7 @@ 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 inline blind-filter regex vocabulary. Every value
+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
@@ -31,7 +31,9 @@ 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). Every
+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
@@ -67,16 +69,19 @@ writes.
 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/C++
+# 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).
-MAPLLM_EXTRA_INCLUDE_EXT = (".c", ".h", ".cpp", ".hpp", ".rs")
+# 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")
 
 
 # ===========================================================================
@@ -104,6 +109,14 @@ MAPLLM_EXTRA_INCLUDE_EXT = (".c", ".h", ".cpp", ".hpp", ".rs")
 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",)
 
 # TYPE_SYMBOL_KINDS (Java W1 repair -- the wall-legal PRODUCT-side
 # mirror of ambitgraph/codelib.py's own _TYPE_SYMBOL_KINDS): the literal
@@ -120,6 +133,22 @@ JAVA_LANGS = ("java",)
 # 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")
+
 # 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
@@ -183,7 +212,15 @@ ROUTEDNESS_LANGS = ("jsp", "jspf", "java")
 #      flask_pack) to have DETECTED this run.
 # ===========================================================================
 KIND_READER_LANGS = {
-    "include/static": frozenset({"jsp"}),
+    # "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.
+    "include/static": frozenset({"jsp", "c"}),
     "include/import.py": frozenset({"py"}),
     "include/import.js": frozenset({"js"}),
     # Java W1 (2026-09-02), additive: langs.py's java LangSpec gains
@@ -195,7 +232,29 @@ KIND_READER_LANGS = {
     "include/reexport": frozenset({"js"}),
     "include/dynamic-import": frozenset({"js"}),
     "include/member-resolved": frozenset({"js"}),
-    "calls": frozenset({"jsp", "java", "py", "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.
+    "calls": frozenset({"jsp", "java", "py", "js", "c"}),
     "reference/script": frozenset({"jsp"}),
     "route/mount": frozenset({"py", "js"}),
     "ui/component-use": frozenset({"js"}),
@@ -219,25 +278,105 @@ KIND_READER_LANGS = {
 # ===========================================================================
 _GRAMMAR_EXTS = frozenset({
     ".jsp", ".jspf", ".java", ".js", ".mjs", ".cjs", ".jsx", ".ts", ".tsx",
-    ".py", ".sh", ".sql",
+    ".py", ".sh", ".sql", ".c", ".h",
 })
 
 
 # ===========================================================================
-# CENSUS fact 8's disclosure-gate vocabulary -- formerly
-# ambit_map/library.py's own inline regex literal, r"\bjsp\b|\bjava\b".
-# Declared as its OWN field, NEVER derived from a lang-tag grouping above
-# (R4-DESIGN.md v2's explicit ruling, JUDGES-DIGEST.txt LENS 1/2 finding on
-# the blind filter): this is a vocabulary of ENGLISH WORDS a disclosure
-# SENTENCE spells, not a vocabulary of `lang` tag values, and the two
-# differ on purpose. Joining it from ROUTEDNESS_LANGS above would either
-# resurrect "jspf" into the regex (no disclosure sentence anywhere spells
-# the standalone word "jspf" -- ROUTEDNESS_LANGS keeps it only for
-# producer-portability tolerance, never because prose says it) or, joined
-# from JS_LANGS, mint useless/dangerous words no disclosure sentence uses
-# standalone this way ("ts", "cjs") or that collide with ordinary English
-# ("js" inside other tokens). ambit_map/library.py's own _BLIND_LANG_FILTER
-# compiles its regex from exactly these two words, `\b<word>\b` each,
-# joined with `|` -- byte-identical to the pattern it replaces.
+# 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.
 # ===========================================================================
-BLIND_LANG_PROSE_WORDS = ("jsp", "java")
+_JSP_JAVA = frozenset({"jsp", "jspf", "java"})
+_C = frozenset({"c"})
+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),
+)
+
+
+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)

{ambitgraph-0.3.0 → ambitgraph-0.4.0}/ambit_map/library.py

@@ -22,7 +22,6 @@ per (model, dialects) OBJECT IDENTITY, file-local to this module -- see the
 comment above `_MOUNTS_CACHE_MAXSIZE` below for the full argument.
 """
 import collections
-import re
 import threading
 
 from . import registry as reg
@@ -890,42 +889,38 @@ def _method_note1(dialects):
     return ob.note(lead + "".join(clauses))
 
 
-# Word-boundary, not substring: a bare `"jsp" in s.lower()` also matches
-# every sentence that merely contains "jsp" as part of a longer token, and
-# a bare "java" substring check would ALSO match "javascript"/"javadoc" --
-# neither is the language name this filter exists to drop. `\bjava\b`
-# never matches "javascript" (no boundary follows "java" there) or
-# "javadoc" (same reason), so only the standalone word is caught.
-#
-# R4: the two words themselves now live at ambit_map/langmirror.py's own
-# BLIND_LANG_PROSE_WORDS, declared as their OWN field rather than derived
-# from ROUTEDNESS_LANGS/JS_LANGS above (that module's own comment states
-# why: a vocabulary of English disclosure words, not of `lang` tags). The
-# compiled pattern is byte-identical to the literal it replaces,
-# r"\bjsp\b|\bjava\b".
-_BLIND_LANG_FILTER = re.compile(
-    "|".join(r"\b%s\b" % re.escape(w) for w in langm.BLIND_LANG_PROSE_WORDS),
-    re.IGNORECASE)
+# THE PER-SENTENCE LANGUAGE TAG's product-side reader. The table it reads
+# (langmirror.BLIND_SENTENCE_LANGS) and this function are declared together
+# in ambit_map/langmirror.py, beside every other copy of an engine fact
+# that crosses the wall; this alias is what `_blind_for_run` below calls,
+# the same alias-only shape registry.py's JS_LANGS/PY_LANGS already use.
+_blind_langs = langm.blind_langs
 
 
 def _blind_for_run(cov, model):
     """`_combined_blind` (DATA/LOGIC, kept verbatim -- other call sites in
     this module still want the RAW list) always carries the engine's
-    static, always-present disclosures, including the JSP/Java-scriptlet
-    and JSP/Java-namespace sentences -- the comment above
-    ambitgraph.symbols.BLIND_SENTENCES says so explicitly ("always
-    present, regardless of what the scanned tree happens to contain"). Review fix (major): on a run with zero jsp/jspf/
-    java units those two sentences named a language the page never scanned
-    (chatbot-ui, flask), so THIS caller -- the only live caller of
-    `_combined_blind` in the new render_library flow -- drops any sentence
-    naming JSP or Java when the run holds no jsp/jspf/java unit at all. The
-    RAW list (with those sentences) still reaches `_find_blind`'s other
-    callers unfiltered, since ZERO_DDL_MATCH/CALL_BLIND_MATCH need the
-    full list regardless of language mix."""
+    static, always-present disclosures, whatever the scanned tree happens
+    to contain -- the comment above ambitgraph.symbols.BLIND_SENTENCES
+    says so explicitly. A sentence naming a language is a true statement
+    only about a run that holds a unit of that language, so this caller
+    keeps a sentence when it is universal (no tag) or its tags meet the
+    run's own languages, and drops it otherwise.
+
+    Per sentence, not per run: a run holding one tagged language keeps
+    that language's sentences and still drops another language's, which
+    an all-or-nothing gate on the run could not express. The RAW list
+    still reaches `_find_blind`'s other callers unfiltered -- the graph
+    page's no-edges note states the call-graph law on runs of every
+    language mix."""
     blind = _combined_blind(cov)
-    if any(u.lang in langm.ROUTEDNESS_LANGS for u in model.units.values()):
-        return blind
-    return [s for s in blind if not _BLIND_LANG_FILTER.search(s)]
+    run_langs = {u.lang for u in model.units.values()}
+    out = []
+    for s in blind:
+        tags = _blind_langs(s)
+        if not tags or (tags & run_langs):
+            out.append(s)
+    return out
 
 
 def _method_note2(model, envelope, grammarless_table=False):

{ambitgraph-0.3.0 → ambitgraph-0.4.0}/ambit_map/orchestrate.py

@@ -106,13 +106,14 @@ MEASURED_SECONDS_PER_FILE = 0.080
 ENGINE_DEFAULT_INCLUDE_EXT = langm.ENGINE_DEFAULT_INCLUDE_EXT
 # C2 (mapllm wave): the extra extensions a mapllm run admits beyond the
 # shared engine default above -- world-popularity order per the founder's
-# list, the C/C++ foundation first. `map`'s and `scan`'s own defaults stay
-# BYTE-UNTOUCHED (the ENGINE_DEFAULT_INCLUDE_EXT equality pin just above
-# stays green, unchanged): this list only ever widens a mapllm run's OWN
-# generated product config (product_config()/write_product_config()/
-# plan()'s own extra_include_ext argument, below), never
-# ENGINE_DEFAULT_INCLUDE_EXT itself. R4: sourced from langmirror.py, same
-# posture as the admission tuple above.
+# list, the C++ foundation first (C itself moved into the shared engine
+# default above once it gained a real LangSpec). `map`'s and `scan`'s own
+# defaults stay BYTE-UNTOUCHED (the ENGINE_DEFAULT_INCLUDE_EXT equality
+# pin just above stays green, unchanged): this list only ever widens a
+# mapllm run's OWN generated product config (product_config()/
+# write_product_config()/plan()'s own extra_include_ext argument, below),
+# never ENGINE_DEFAULT_INCLUDE_EXT itself. R4: sourced from langmirror.py,
+# same posture as the admission tuple above.
 MAPLLM_EXTRA_INCLUDE_EXT = langm.MAPLLM_EXTRA_INCLUDE_EXT
 FAIL_TAIL_CHARS = 1200
 DIALECT_FILENAME = "product-dialect.json"

{ambitgraph-0.3.0 → ambitgraph-0.4.0}/ambit_map/registry.py

@@ -116,10 +116,20 @@ PY_LANGS = langm.PY_LANGS
 # include/import.py and include/import.js. Same alias-only shape as the
 # two lines above.
 JAVA_LANGS = langm.JAVA_LANGS
+# The fourth src_lang bucket, same alias-only shape as the three above:
+# kind_key's include branch reads it to route a C preprocessor include,
+# and unitpage.py's class-count bucket reads it as the gate on
+# C_TYPE_SYMBOL_KINDS below.
+C_LANGS = langm.C_LANGS
 # Java W1 repair (2026-09-02), additive: the same alias-only
 # shape, for unitpage.py's own class-count bucket -- see langmirror.py's
 # own comment on this field for the producer/consumer/diff story.
 TYPE_SYMBOL_KINDS = langm.TYPE_SYMBOL_KINDS
+# The C half of the same bucket -- the kind strings extract_c_symbols
+# emits for a type declaration; see langmirror.py's own comment on this
+# field for the producer/consumer/diff story, and for why "enum" being a
+# member of both sets is safe (the two language gates are disjoint).
+C_TYPE_SYMBOL_KINDS = langm.C_TYPE_SYMBOL_KINDS
 # Java W1 repair, additive: the language gate that
 # TYPE_SYMBOL_KINDS' unitpage consumer needs -- same alias-only shape;
 # see langmirror.py's own comment on this field.
@@ -263,8 +273,13 @@ _TEMPLATES = {
     "reference/script": (
         "{A} loads {B} as a script tag — a browser-side reference, not "
         "a server-side include."),
+    # One sentence for every row on the calls plane, so it names a
+    # BINDING rather than a match: Java's exact-evidence tiers bind a
+    # site through the caller's own imports and package, while every
+    # lane's fallback tier matches a repo-unique name -- both are static
+    # reads of source text, and neither traces execution.
     "calls": (
-        "{A} calls {B} at {n} site(s) — a static name match, not a "
+        "{A} calls {B} at {n} site(s) — a static name binding, not a "
         "traced call."),
     "table/read": "{A} reads the {t} table.",
     "table/write": "{A} writes the {t} table.",
@@ -365,9 +380,17 @@ _EPISTEMIC = {
     "reference/script": (
         "this is a <script src> tag read from markup; a tag injected by "
         "client-side JS is not seen."),
+    # ambit_map/matched.py's _definer_name_index docstring cites this
+    # string by the exact phrase "unique-name static match" -- that
+    # phrase stays, as the fallback tier's own name, whatever else this
+    # string carries.
     "calls": (
-        "unique-name static match over the JSP/Java namespace only; a name "
-        "defined in two places is dropped rather than guessed."),
+        "every lane ends in the same unique-name static match — a name "
+        "defined in two places is dropped rather than guessed; a Java "
+        "site may first bind proven on exact evidence: a constructor "
+        "resolved through the caller's own imports and package, a static "
+        "receiver resolved there whose method the target file declares, "
+        "or a static import whose target declares the member."),
     "table/read": (
         "a SQL SELECT (or equivalent read) naming a validated table, read "
         "from the source text."),
@@ -493,6 +516,20 @@ def kind_key(plane, kind="", src_lang=""):
         if plane == "include":
             if kind == "static":
                 return "include/static"
+            # The C preprocessor's own edge kind, "include". It lands on
+            # the include/static row deliberately, not on a row of its
+            # own: that row's sentence and epistemic text -- a literal
+            # path read from the source text, spliced in at include time,
+            # never varying at runtime -- is exactly what a C `#include`
+            # is, and a twentieth row would repeat it word for word. The
+            # src_lang gate is what keeps the reuse honest: without it,
+            # any producer's edge spelled kind "include" would inherit
+            # JSP's row by accident. langmirror.KIND_READER_LANGS'
+            # include/static row carries "c" beside "jsp" for the same
+            # reason, and tests/test_langs_mirror_diff.py's include-rows
+            # union check is what holds the two together.
+            if kind == "include" and src_lang in C_LANGS:
+                return "include/static"
             if kind == "import":
                 if src_lang in PY_LANGS:
                     return "include/import.py"
@@ -1011,6 +1048,66 @@ def importer_root_underivable_sentence(A, raw):
                  {"A": A, "raw": raw})
 
 
+# The C include lane's four reason tokens, one sentence each -- the same
+# dispatch the three above ride. EDGE_KINDS["unresolved"]'s own template
+# ("{A} names a target this scan never read...") is false for all four:
+# an angle include is HELD, never searched for; a quoted system header is
+# the toolchain's to find; an absent target may sit in a directory this
+# scan excludes, which is a scope fact, not an unread file; and the last
+# names a file this scan DID read and refused to draw for position. Each
+# sentence says which of those it is, in the same words the run's own
+# coverage sentence uses, so the chip and the disclosure never disagree.
+C_ANGLE_INCLUDE_HELD_SENTENCE = (
+    "{A} names {raw} in angle brackets — the toolchain search path decides "
+    "what that reaches, so the connection is held rather than drawn: a name "
+    "matching inside this scan is not evidence the compiler reached that "
+    "file.")
+_C_ANGLE_INCLUDE_HELD_SLOT_NAMES = ("A", "raw")
+
+
+def c_angle_include_held_sentence(A, raw):
+    return _fill(C_ANGLE_INCLUDE_HELD_SENTENCE,
+                 _C_ANGLE_INCLUDE_HELD_SLOT_NAMES, {"A": A, "raw": raw})
+
+
+C_QUOTED_INCLUDE_SYSTEM_SENTENCE = (
+    "{A} names {raw} — a C standard library header, resolved by the "
+    "toolchain search path rather than by position. Held, not an error "
+    "row: imported third-party code quotes its own system headers.")
+_C_QUOTED_INCLUDE_SYSTEM_SLOT_NAMES = ("A", "raw")
+
+
+def c_quoted_include_system_sentence(A, raw):
+    return _fill(C_QUOTED_INCLUDE_SYSTEM_SENTENCE,
+                 _C_QUOTED_INCLUDE_SYSTEM_SLOT_NAMES, {"A": A, "raw": raw})
+
+
+C_QUOTED_INCLUDE_ABSENT_SENTENCE = (
+    "{A} names {raw} — this scan holds no candidate for it anywhere: the "
+    "target is generated at build time, or it lives in a directory this "
+    "scan excludes, or it is a header from outside this repository that "
+    "the C standard list does not name.")
+_C_QUOTED_INCLUDE_ABSENT_SLOT_NAMES = ("A", "raw")
+
+
+def c_quoted_include_absent_sentence(A, raw):
+    return _fill(C_QUOTED_INCLUDE_ABSENT_SENTENCE,
+                 _C_QUOTED_INCLUDE_ABSENT_SLOT_NAMES, {"A": A, "raw": raw})
+
+
+C_QUOTED_INCLUDE_UNRESOLVED_SENTENCE = (
+    "{A} names {raw} — this scan does hold a file for it, but position "
+    "does not license the edge: a one-segment name is licensed only from "
+    "the including directory, and a multi-segment path must end exactly "
+    "one file in the scan.")
+_C_QUOTED_INCLUDE_UNRESOLVED_SLOT_NAMES = ("A", "raw")
+
+
+def c_quoted_include_unresolved_sentence(A, raw):
+    return _fill(C_QUOTED_INCLUDE_UNRESOLVED_SENTENCE,
+                 _C_QUOTED_INCLUDE_UNRESOLVED_SLOT_NAMES, {"A": A, "raw": raw})
+
+
 def unresolved_reason_sentence(reason, A, raw):
     """The reason-token dispatch every unresolved-ref caption site shares
     (graph.py's _quarantine_note, unitpage.py's connections block): maps
@@ -1025,6 +1122,14 @@ def unresolved_reason_sentence(reason, A, raw):
         return wildcard_import_sentence(A=A, raw=raw)
     if reason == "importer_root_underivable":
         return importer_root_underivable_sentence(A=A, raw=raw)
+    if reason == "c_angle_include_held":
+        return c_angle_include_held_sentence(A=A, raw=raw)
+    if reason == "c_quoted_include_unresolved_system":
+        return c_quoted_include_system_sentence(A=A, raw=raw)
+    if reason == "c_quoted_include_unresolved_absent":
+        return c_quoted_include_absent_sentence(A=A, raw=raw)
+    if reason == "c_quoted_include_unresolved":
+        return c_quoted_include_unresolved_sentence(A=A, raw=raw)
     return ""
 
 
@@ -1142,6 +1247,14 @@ UNIT_STORY_LEAD_NOLANG = "{name} — {lines} lines"
 UNIT_STORY_HOLDS = "the scan read {parts}"
 UNIT_STORY_FNS = "{n} function(s)"
 UNIT_STORY_CLASSES = "{n} class(es)"
+# The same bucket, worded for a language that has no classes. C's type
+# declarations are structs, unions, enums and typedefs, and counting them
+# under a word C does not have is a false statement about the file in the
+# first sentence of its page -- so the CALLER, which is where the language
+# gate on this count already lives, names the word and unit_story renders
+# whichever one it is handed. "type" is registered in _COUNT_NOUNS below,
+# without which "1 type(s)" would ship its inflection marker to a reader.
+UNIT_STORY_TYPES = "{n} type(s)"
 # review fix (blocker, 2026-08-26): a unit whose symbols are all a kind
 # other than function/method/class (a SQL table/index/trigger/sql_function,
 # a TS interface/type/const...) used to fall through to UNIT_STORY_NO_SYMS
@@ -1237,8 +1350,16 @@ def _pos(n):
     return isinstance(n, int) and not isinstance(n, bool) and n > 0
 
 
-def unit_story(name, lang, lines, f, c, t, inbound, edges_damaged=False, other=0):
-    """One sentence, no language-specific clause ever. Every zero clause is
+def unit_story(name, lang, lines, f, c, t, inbound, edges_damaged=False, other=0,
+               class_word=UNIT_STORY_CLASSES):
+    """One sentence, no language-specific CLAUSE ever. `class_word` is the
+    one language-shaped choice, and it is the caller's: the type-count
+    bucket is filled under a per-language gate that lives there, and a
+    language with no classes must not have its types counted under that
+    word. The default renders the sentence every non-C page has always
+    rendered, so a caller that never passes it is byte-unchanged.
+
+    Every zero clause is
     OMITTED by the builder -- never a bare 0. `edges_damaged` replaces the
     touches/inbound clauses with one honest "unknown" clause instead of a
     false zero. `other` (review fix, blocker) is every symbol counted
@@ -1252,7 +1373,7 @@ def unit_story(name, lang, lines, f, c, t, inbound, edges_damaged=False, other=0
     if _pos(f):
         holds_parts.append(UNIT_STORY_FNS.format(n=f))
     if _pos(c):
-        holds_parts.append(UNIT_STORY_CLASSES.format(n=c))
+        holds_parts.append(class_word.format(n=c))
     if _pos(other):
         holds_parts.append(UNIT_STORY_OTHER.format(n=other))
     segments = []
@@ -1676,7 +1797,7 @@ _COUNT_NOUNS = ("bucket", "class", "column", "day", "directory", "edge",
                 "match", "minute", "name", "neighbour", "node", "note",
                 "noun", "one", "origin", "page", "path", "reader",
                 "reference", "route", "self-reference", "site", "subtree",
-                "symbol", "table", "unit")
+                "symbol", "table", "type", "unit")
 # Two inflection markers: "(s)" (plural adds "s") and "(es)" (plural adds
 # "es", e.g. "class(es)" -> "class" / "classes"). One alternation, one
 # capture group naming which suffix a hit's own noun takes.

{ambitgraph-0.3.0 → ambitgraph-0.4.0}/ambit_map/unitpage.py

@@ -834,16 +834,34 @@ def render_unit(model, uid, now_iso, uncap=frozenset(), dialects=None, judged=No
         # and a TS interface/enum renders "class(es)" again; revert to
         # the bare "class" check and a Java interface/enum/record falls
         # into "other" -- both directions pinned through a real render.
+        #
+        # The C half of the same bucket, gated the identical way: a C unit
+        # counts its struct/union/enum/typedef declarations as types
+        # (reg.C_TYPE_SYMBOL_KINDS under the reg.C_LANGS gate, both
+        # diffed against ambitgraph.codelib's own sets). The gate is what
+        # keeps "enum" -- a member of BOTH kind sets -- from re-counting a
+        # TypeScript enum: the java and C gates are disjoint and a
+        # non-C, non-java unit meets neither, so every page of every other
+        # language renders byte-identically to before this branch existed.
         java_ns = u.lang in reg.NAMESPACE_LANGS
+        c_ns = u.lang in reg.C_LANGS
         c = sum(1 for s in u.symbols
                 if s.kind == "class"
-                or (java_ns and s.kind in reg.TYPE_SYMBOL_KINDS))
+                or (java_ns and s.kind in reg.TYPE_SYMBOL_KINDS)
+                or (c_ns and s.kind in reg.C_TYPE_SYMBOL_KINDS))
+        # ... and the WORD that bucket is counted under is decided by the
+        # SAME gate. C has no classes at all -- what it declares is
+        # structs, unions, enums and typedefs -- so a C unit's first
+        # sentence would otherwise state a construct the language does not
+        # have, about a file that cannot contain one. Every other language
+        # keeps reg.UNIT_STORY_CLASSES, the default, byte for byte.
+        class_word = reg.UNIT_STORY_TYPES if c_ns else reg.UNIT_STORY_CLASSES
         other = len(u.symbols) - f - c
         t = len({op.table for op in u.table_ops})
         inbound = (len(model.included_by.get(u.uid, ())) + len(model.referenced_by.get(u.uid, ()))
                    + len(model.called_by.get(u.uid, ())))
         story = reg.unit_story(u.uid, u.lang, u.lines, f, c, t, inbound, model.edges_damaged,
-                                other=other)
+                                other=other, class_word=class_word)
 
         hero = ob.hero(
             crumbs=[("AmbitGraph", "/library"), ("Library", "/library"),

{ambitgraph-0.3.0 → ambitgraph-0.4.0}/ambitgraph/__init__.py

@@ -3,4 +3,4 @@
 Phase 1: the scan. Read-only, always.
 """
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"