# Bundled core Dynamic classification Source revision: `md5:072dcbd99dc44473ac45eb233dfb5fb6`. Inventory: **278** schema-Dynamic positions across **194** definitions. Current unresolved migration queue: **0** positions. Every position has an owning subsystem and an explicit migration decision. `retain-reviewed` is not an exemption: the existing per-definition quality baseline rejects growth. `migrate` is the ordered cleanup queue for caller-visible contracts. ## Summary | Decision / owner | Positions | | --- | ---: | | retain-reviewed/compiler-forms | 28 | | retain-reviewed/compiler-specialized-contracts | 28 | | retain-reviewed/legacy-compatibility-boundaries | 1 | | retain-reviewed/macro-system | 94 | | retain-reviewed/open-data-boundaries | 22 | | retain-reviewed/public-open-boundaries | 9 | | retain-reviewed/runtime-internals | 52 | | retain-reviewed/runtime-primitives | 43 | | retain-reviewed/test-library | 1 | ## Complete inventory | Definition | Schema path | Analysis intent | Owner | Decision | Rationale | | --- | --- | --- | --- | --- | --- | | `calcit.core/%::` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/%{}` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/&` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/&=` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&=` | `schema.args.1` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&buffer` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&call-spread` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/&case` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/&case` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/&case` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/&cirru-quote:to-list` | `schema.return.item` | unresolved | public-open-boundaries | retain-reviewed | CirruQuote converts to a recursively heterogeneous syntax tree whose leaf-or-list union is not expressible; consumers must parse or narrow nodes before ordinary typed processing. | | `calcit.core/&compare` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&compare` | `schema.args.1` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&core-enum-impls` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-enum-methods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-fn-impls` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-fn-methods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-list-impls` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-list-methods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-map-impls` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-map-methods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-number-impls` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-number-methods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-scalar-impls` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-set-impls` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-set-methods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-string-impls` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-string-methods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-struct-impls` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&core-struct-methods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&data-to-code` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/&doseq` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/&enum:params` | `schema.return.item` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&extract-code-into-edn` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/&format-ternary-tree` | `schema.args.0.item` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&get-def-doc` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&get-def-schema` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&get-def-schema` | `schema.return` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&get-in` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&get-in` | `schema.return.item` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&get-raw` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&get-raw` | `schema.args.1` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&get-raw` | `schema.return` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&hash` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&impl::new` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&impl:get` | `schema.args.1` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&impl:get` | `schema.return` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&impl:nth` | `schema.return` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&let` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/&list-match-internal` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/&list-match-internal` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/&list:flatten` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&list:flatten` | `schema.return.item` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&list:foldl-shortcut` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&list:sort-by` | `schema.args.1` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&str` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&struct-match-internal` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/&struct-match-internal` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/&struct:assoc` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&struct:contains?` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&struct:extend-as` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&struct:from-map` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&struct:get` | `schema.return` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&struct:matches?` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&struct:to-map` | `schema.return.value` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&struct:with` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/&trait::new` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/&{}` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/'` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/->` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/->` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/->%` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/->%` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/->%` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/->>` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/->>` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/:` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/::` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/?` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/MapEntryDecision` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/Option` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/OptionMethods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/Result` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/ResultMethods` | `schema` | unresolved | runtime-internals | retain-reviewed | This definition transports compiler/runtime nominal metadata rather than ordinary application data. | | `calcit.core/and` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/and` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/any?` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | The public facade accepts several runtime collection families; known List, Set, and Map receivers specialize the predicate input, with focused callback mismatch regressions preserving member or heterogeneous pair evidence. | | `calcit.core/apply` | `schema.return` | unresolved | compiler-specialized-contracts | retain-reviewed | Arbitrary callable arity is not representable in the schema; compatible homogeneous List calls recover the callable return type at preprocessing time, while unproved calls remain Dynamic. | | `calcit.core/apply-args` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/assert` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/assert` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/assert-detect` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/assert-detect` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/assert-type` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/assert=` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/assert=` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/assoc-in` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Fully typed nested Map receivers with non-empty literal paths are lowered to direct typed lookup and reconstruction; dynamic or mixed-container paths remain an explicit compatibility fallback. | | `calcit.core/assoc-in` | `schema.args.2` | unresolved | compiler-specialized-contracts | retain-reviewed | Typed literal Map paths validate the replacement against the recovered leaf type before direct reconstruction; dynamic paths cannot honestly relate this value in the public fallback schema. | | `calcit.core/assoc-in` | `schema.return` | unresolved | compiler-specialized-contracts | retain-reviewed | Typed literal Map paths rebuild and preserve the concrete receiver type; dynamic or mixed-container paths retain the representation-polymorphic runtime result. | | `calcit.core/case` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/case` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/case-default` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/case-default` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/case-default` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/cond` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/data-definition-form` | `schema.args.0` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/data-definition-form` | `schema.return` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/data-definition-malformed-nesting?` | `schema.args.0` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/data-definition-where-form?` | `schema.args.0` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/decode-map-as` | `schema.args.0` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/decode-map-as` | `schema.args.1` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/decode-map-as` | `schema.return` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/def` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/def` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/defmacro` | `schema.args.0` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/defmacro` | `schema.args.1` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/defmacro` | `schema.args.2` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/defmacro` | `schema.return` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/defn` | `schema.args.0` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/defn` | `schema.args.1` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/defn` | `schema.args.2` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/defn` | `schema.return` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/do` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/do` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/each` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Known List and Set receivers specialize callbacks to the member type, while Map callbacks receive the honest heterogeneous runtime pair; focused mismatch regressions cover all three families. | | `calcit.core/either` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/either` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/eval` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/every?` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Known List and Set receivers specialize Bool predicates to the member type, while Map predicates receive the honest heterogeneous runtime pair; focused mismatch regressions cover these contracts. | | `calcit.core/ffi:response` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/ffi:task` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/filter` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Known List, Set, and Map receivers select typed shape-preserving implementations and specialize predicate inputs; unsupported runtime-polymorphic receivers stay on the compatibility facade. | | `calcit.core/filter` | `schema.return` | unresolved | compiler-specialized-contracts | retain-reviewed | A statically known List, Map, or Set receiver is rewritten to its typed core filter implementation, which preserves the receiver collection shape; the representation-polymorphic facade receiver is reviewed alongside this specialization. | | `calcit.core/first` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | List, String, and Enum receivers recover their indexed payload through preprocessing; the facade remains representation-polymorphic because the type grammar has no shared sequence capability with an associated item type. | | `calcit.core/first` | `schema.return.type-arg.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Supported sequence receivers recover the Option payload from List, String, or Enum evidence; the representation-polymorphic facade receiver is reviewed alongside this specialization. | | `calcit.core/flipped` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/flipped` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/flipped` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/fn` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/format-cirru` | `schema.args.0.item` | unresolved | public-open-boundaries | retain-reviewed | The formatter consumes recursively heterogeneous Cirru syntax nodes; the missing recursive leaf-or-list union is retained as a reviewed presentation boundary. | | `calcit.core/format-cirru-one-liner` | `schema.args.0.item` | unresolved | public-open-boundaries | retain-reviewed | The one-line formatter consumes recursively heterogeneous Cirru syntax nodes; the missing recursive leaf-or-list union is retained as a reviewed presentation boundary. | | `calcit.core/gensym` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/get` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Known Map, List, String, and Enum receivers drive key checking and Option payload inference; the facade receiver remains open because these families do not share an expressible associated lookup contract. | | `calcit.core/get` | `schema.args.1` | unresolved | compiler-specialized-contracts | retain-reviewed | The receiver specializes the lookup key to the Map key or indexed Number contract; the representation-polymorphic facade receiver is reviewed alongside this specialization. | | `calcit.core/get` | `schema.return.type-arg.0` | unresolved | compiler-specialized-contracts | retain-reviewed | The receiver specializes the Option payload to the Map value, List member, or String character contract; the representation-polymorphic facade receiver is reviewed alongside this specialization. | | `calcit.core/get-in` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Fully typed receivers with known literal paths recover each lookup hop and the Option payload; dynamic paths remain an explicit open-data compatibility boundary and Struct traversal is rejected. | | `calcit.core/get-in` | `schema.return.type-arg.0` | unresolved | compiler-specialized-contracts | retain-reviewed | A statically typed receiver plus a fully known literal Map/List path recovers the Option payload at preprocessing time; dynamic paths and Struct traversal remain on the reviewed fallback. | | `calcit.core/hint-fn` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/if` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/if-let` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/if-let` | `schema.inputs.2.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/if-let` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/if-not` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/if-not` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/impl-traits` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/impl-traits` | `schema.return` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/includes?` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Known Map, List, Set, and String receivers specialize the searched value contract; the public facade keeps the heterogeneous receiver boundary because no common associated-member capability is expressible. | | `calcit.core/includes?` | `schema.args.1` | unresolved | compiler-specialized-contracts | retain-reviewed | The receiver specializes the searched value to the Map value, collection member, or String contract; the representation-polymorphic facade receiver is reviewed alongside this specialization. | | `calcit.core/json-parse` | `schema.return` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/last` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | List, String, and Enum receivers recover their indexed payload through preprocessing; the facade remains representation-polymorphic because the type grammar has no shared sequence capability with an associated item type. | | `calcit.core/last` | `schema.return.type-arg.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Supported sequence receivers recover the Option payload from List, String, or Enum evidence; the representation-polymorphic facade receiver is reviewed alongside this specialization. | | `calcit.core/let` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let-destruct` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let-destruct` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let-destruct` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let-sugar` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let-sugar` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let[]` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let[]` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let[]` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let{}` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let{}` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/let{}` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/list-match` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/loop` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/loop` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/macroexpand` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/macroexpand-1` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/macroexpand-all` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/map` | `schema.return` | unresolved | compiler-specialized-contracts | retain-reviewed | Known List, Set, and Map receivers select typed native implementations whose result follows the callback and receiver family; the public Mappable trait currently cannot express an associated output constructor. | | `calcit.core/map-kv` | `schema.return` | unresolved | legacy-compatibility-boundaries | retain-reviewed | Legacy map-kv accepts an untyped two-item List or a nil/enum drop sentinel, so its output key/value relation cannot be proven. Typed callers receive W_MAP_KV_UNPROVEN_CONTRACT and must migrate to filter-map-kv. | | `calcit.core/nth` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | List, String, and Enum receivers recover their indexed payload and enforce a Number index; the facade remains open because their shared associated-item capability is not expressible. | | `calcit.core/nth` | `schema.return.type-arg.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Supported indexed receivers recover the Option payload from List, String, or Enum evidence; the representation-polymorphic facade receiver is reviewed alongside this specialization. | | `calcit.core/option:let` | `schema.expansion.type-arg.0` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/or` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/or` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/or` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/parse-cirru-edn` | `schema.return` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/parse-cirru-list` | `schema.return.item` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/quasiquote` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/quote` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/recur` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/some-in?` | `schema.args.0` | unresolved | public-open-boundaries | retain-reviewed | This compatibility predicate accepts open data and dynamic paths; fully typed callers should use get-in and inspect its Option result so the recovered payload remains visible. | | `calcit.core/str` | `schema.args.0` | unresolved | public-open-boundaries | retain-reviewed | String conversion deliberately accepts every runtime value; Dynamic is the honest universal presentation input rather than lost business-domain evidence. | | `calcit.core/str` | `schema.rest` | unresolved | public-open-boundaries | retain-reviewed | Variadic string conversion deliberately accepts every runtime value; Dynamic is the honest universal presentation input rather than a relation between arguments. | | `calcit.core/str-spaced` | `schema.rest` | unresolved | public-open-boundaries | retain-reviewed | Variadic spaced string conversion deliberately accepts every runtime value; Dynamic is the honest universal presentation input rather than a relation between arguments. | | `calcit.core/struct-match` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/struct-match` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/swap!` | `schema.inputs.0.expr.item` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/swap!` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/tag-match` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/tag-match` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/tagging-edn` | `schema.args.0` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/tagging-edn` | `schema.return` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/try` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/try-decode-map-as` | `schema.args.0` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/try-decode-map-as` | `schema.args.1` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/try-decode-map-as` | `schema.return` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/try-parse-cirru-edn` | `schema.return.type-arg.0` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/try-parse-cirru-edn-as` | `schema.args.1` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/try-parse-cirru-edn-as` | `schema.return` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/try-parse-cirru-list` | `schema.return.type-arg.0.item` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/try-parse-json` | `schema.return.type-arg.0` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/tuple-enum` | `schema.args.0` | unresolved | public-open-boundaries | retain-reviewed | This runtime inspection helper accepts arbitrary values and returns Option; callers gain evidence only by handling the Option result, so its input is intentionally universal. | | `calcit.core/tuple?` | `schema.args.0` | unresolved | public-open-boundaries | retain-reviewed | A runtime shape predicate must accept arbitrary values in order to narrow them; its Dynamic input is intentional and its Bool output is concrete. | | `calcit.core/turn-symbol` | `schema.args.0` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/turn-symbol` | `schema.return` | unresolved | open-data-boundaries | retain-reviewed | The parser/decoder boundary accepts open data; callers must decode or narrow before entering nominal business APIs. | | `calcit.core/unsafe-coerce` | `schema` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/update` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Known List, Map, and Struct receivers specialize the index or key and updater callback, and preserve the receiver as the result; the facade receiver covers incompatible runtime representations. | | `calcit.core/update` | `schema.args.1` | unresolved | compiler-specialized-contracts | retain-reviewed | The receiver specializes the update key or index and the updater callback contract; the representation-polymorphic facade receiver is reviewed alongside this specialization. | | `calcit.core/update` | `schema.return` | unresolved | compiler-specialized-contracts | retain-reviewed | Preprocessing preserves the concrete collection or Struct receiver as the update result; the representation-polymorphic facade receiver is reviewed alongside this specialization. | | `calcit.core/update-in` | `schema.args.0` | unresolved | compiler-specialized-contracts | retain-reviewed | Fully typed nested Map receivers with non-empty literal paths are lowered to direct typed lookup and reconstruction; dynamic or mixed-container paths remain an explicit compatibility fallback. | | `calcit.core/update-in` | `schema.return` | unresolved | compiler-specialized-contracts | retain-reviewed | Typed literal Map paths pass Option to the updater and rebuild the concrete receiver type; the dynamic-path runtime fallback cannot expose that dependent relation in the current schema grammar. | | `calcit.core/when` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/when` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/when` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/when-let` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/when-let` | `schema.expansion.type-arg.0` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/when-not` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/when-not` | `schema.rest.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/when-not` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/with-gensyms` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/with-type-slot` | `schema.args.0` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/with-type-slot` | `schema.return` | unresolved | runtime-primitives | retain-reviewed | The low-level runtime operation is deliberately representation-polymorphic; typed project APIs must not use it as an escape hatch. | | `calcit.core/{,}` | `schema.expansion.key` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/{,}` | `schema.expansion.value` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/{}` | `schema.expansion.key` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/{}` | `schema.expansion.value` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.core/~` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.core/~@` | `schema` | unresolved | compiler-forms | retain-reviewed | This compiler form consumes or produces code/syntax whose value shape is phase-dependent. | | `calcit.internal/&core-add-list-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-add-number-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-add-string-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-compare-number-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-compare-string-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-contains-enum-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-contains-list-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-contains-map-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-contains-set-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-contains-string-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-contains-struct-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-countable-enum-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-countable-list-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-countable-map-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-countable-set-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-countable-string-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-countable-struct-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-debug-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-eq-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-len-list-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-len-map-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-len-set-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-len-string-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-mappable-list-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-mappable-map-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-mappable-set-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&core-multiply-number-impl` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.internal/&tag-match-internal` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.internal/&tag-match-internal` | `schema.expansion` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.internal/normalize-trait-type` | `schema` | unresolved | runtime-internals | retain-reviewed | Compiler-owned trait/impl metadata is not a public value contract; keep it visible and baseline-locked. | | `calcit.test/fail` | `schema.return` | unresolved | test-library | retain-reviewed | The test helper always raises and therefore has no runtime return value; until the type grammar has a bottom/Never type, Dynamic is the honest non-returning test boundary. | | `calcit.test/is` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.test/is-not=` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.test/is-not=` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.test/is-throws` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.test/is=` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.test/is=` | `schema.inputs.1.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. | | `calcit.test/throws?` | `schema.inputs.0.expr` | intentional-macro-syntax | macro-system | retain-reviewed | Phase-aware macro syntax is intentionally open; the per-definition quality baseline prevents growth. |