type-python 0.1.1__tar.gz → 0.2.0__tar.gz

{type_python-0.1.1 → type_python-0.2.0}/Cargo.lock

@@ -1779,7 +1779,7 @@ dependencies = [
 
 [[package]]
 name = "typepython-binding"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "typepython-diagnostics",
  "typepython-syntax",
@@ -1787,20 +1787,22 @@ dependencies = [
 
 [[package]]
 name = "typepython-checking"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "criterion",
+ "proptest",
  "typepython-binding",
  "typepython-config",
  "typepython-diagnostics",
  "typepython-graph",
  "typepython-incremental",
  "typepython-syntax",
+ "typepython-target",
 ]
 
 [[package]]
 name = "typepython-cli"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -1813,6 +1815,7 @@ dependencies = [
  "serde",
  "serde_json",
  "tar",
+ "toml",
  "tracing",
  "tracing-subscriber",
  "typepython-binding",
@@ -1826,21 +1829,23 @@ dependencies = [
  "typepython-lsp",
  "typepython-project",
  "typepython-syntax",
+ "typepython-target",
  "zip",
 ]
 
 [[package]]
 name = "typepython-config"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "serde",
  "thiserror",
  "toml",
+ "typepython-target",
 ]
 
 [[package]]
 name = "typepython-diagnostics"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -1848,7 +1853,7 @@ dependencies = [
 
 [[package]]
 name = "typepython-emit"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "insta",
  "littrs-ruff-python-ast",
@@ -1861,7 +1866,7 @@ dependencies = [
 
 [[package]]
 name = "typepython-graph"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "criterion",
  "typepython-binding",
@@ -1870,18 +1875,19 @@ dependencies = [
 
 [[package]]
 name = "typepython-incremental"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "serde",
  "serde_json",
  "typepython-binding",
  "typepython-graph",
  "typepython-syntax",
+ "typepython-target",
 ]
 
 [[package]]
 name = "typepython-lowering"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "criterion",
  "insta",
@@ -1891,11 +1897,12 @@ dependencies = [
  "proptest",
  "typepython-diagnostics",
  "typepython-syntax",
+ "typepython-target",
 ]
 
 [[package]]
 name = "typepython-lsp"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "criterion",
@@ -1917,7 +1924,7 @@ dependencies = [
 
 [[package]]
 name = "typepython-project"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "glob",
@@ -1931,7 +1938,7 @@ dependencies = [
 
 [[package]]
 name = "typepython-syntax"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "criterion",
  "littrs-ruff-python-ast",
@@ -1939,9 +1946,17 @@ dependencies = [
  "littrs-ruff-text-size",
  "proptest",
  "serde",
+ "toml",
  "typepython-diagnostics",
 ]
 
+[[package]]
+name = "typepython-target"
+version = "0.2.0"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "unarray"
 version = "0.1.4"

{type_python-0.1.1 → type_python-0.2.0}/Cargo.toml

@@ -12,6 +12,7 @@ members = [
     "crates/typepython_lsp",
     "crates/typepython_project",
     "crates/typepython_syntax",
+    "crates/typepython_target",
 ]
 resolver = "3"
 
@@ -20,7 +21,7 @@ authors = ["unadlib"]
 edition = "2024"
 license = "MIT"
 rust-version = "1.85"
-version = "0.1.1"
+version = "0.2.0"
 
 [workspace.dependencies]
 anyhow = "1"

{type_python-0.1.1 → type_python-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: type-python
-Version: 0.1.1
+Version: 0.2.0
 Summary: A statically-typed authoring language that compiles to standard Python
 Author: unadlib
 License-Expression: MIT

{type_python-0.1.1 → type_python-0.2.0}/README.md

@@ -8,7 +8,7 @@
 
 **A statically-typed authoring language that compiles to standard Python.**
 
-Write `.tpy` files with `interface`, `data class`, `sealed class`, inline generics, and strict null safety. The compiler emits standard `.py` + `.pyi` artifacts for Python 3.10-3.12, using standard typing constructs and `typing_extensions` backports where needed, so the result can be checked by tools like mypy, pyright, or ty. No custom runtime, no proprietary type forms.
+Write `.tpy` files with `interface`, `data class`, `sealed class`, inline generics, and strict null safety. The compiler emits standard `.py` + `.pyi` artifacts for Python 3.10-3.14. Targets 3.10-3.12 default to a compatibility-oriented lowering path; targets 3.13+ default to native typing syntax when the runtime supports it. No custom runtime, no proprietary type forms.
 
 ---
 
@@ -19,7 +19,7 @@ pip install type-python
 typepython --help
 ```
 
-The Python package bridge supports Python 3.9+. Generated TypePython projects currently target Python 3.10, 3.11, or 3.12.
+The Python package bridge supports Python 3.9+. Generated TypePython projects can currently target Python 3.10 through 3.14.
 Published wheels are platform-specific because they bundle the Rust CLI binary. Supported releases publish prebuilt wheels for Windows AMD64, macOS x86_64, macOS arm64, and Linux x86_64, so those platforms can install and run TypePython without Rust. Other platforms fall back to the source distribution and require Rust + `cargo`.
 The workspace MSRV is Rust 1.85. `./scripts/bootstrap-rust.sh` installs the pinned Rust 1.94.0 development toolchain used by CI.
 
@@ -71,7 +71,7 @@ The compiler outputs:
 | `def first[T](xs: list[T]) -> T:` | Materialized `TypeVar` plus ordinary generic `def` |
 | `unsafe: eval(expr)`              | `if True: eval(expr)`                              |
 
-Emitted `.py` and `.pyi` use standard Python typing constructs plus `typing_extensions` compatibility imports when needed for the configured target version. Downstream consumers never need the TypePython compiler or a TypePython-specific runtime.
+Emitted `.py` and `.pyi` use standard Python typing constructs plus `typing_extensions` compatibility imports when needed for the configured target version. Targets 3.10-3.12 default to `emit.emit_style = "compat"`, while 3.13+ default to `emit.emit_style = "native"`. Downstream consumers never need the TypePython compiler or a TypePython-specific runtime.
 
 ## Why TypePython
 
@@ -107,7 +107,7 @@ TypePython is an authoring layer, not a replacement for external checkers. One i
 
 ## Features
 
-- **Compiles to Python** -- `.tpy` emits standard `.py` + `.pyi` for target Python 3.10-3.12, using `typing_extensions` compatibility imports when needed ([syntax guide](docs/syntax-guide.md))
+- **Compiles to Python** -- `.tpy` emits standard `.py` + `.pyi` for target Python 3.10-3.14, with compat/native emit styles chosen by target or overridden explicitly ([syntax guide](docs/syntax-guide.md))
 - **Rich type system** -- `unknown`, `dynamic`, `Never`, strict nulls, sealed exhaustiveness, generic defaults, TypeVarTuple ([type system](docs/type-system.md))
 - **Syntax extensions** -- `interface`, `data class`, `sealed class`, `overload def`, `typealias`, `unsafe:`, inline type parameters ([syntax guide](docs/syntax-guide.md))
 - **TypedDict utilities** -- `Partial`, `Required_`, `Readonly`, `Mutable`, `Pick`, `Omit` ([type system](docs/type-system.md))
@@ -115,7 +115,7 @@ TypePython is an authoring layer, not a replacement for external checkers. One i
 - **Full toolchain** -- `init`, `check`, `build`, `watch`, `clean`, `verify`, `migrate` ([CLI reference](docs/cli-reference.md))
 - **LSP server** -- hover, go-to-definition, references, rename, completions, signature help, document symbols, workspace symbols, formatting, code actions, real-time diagnostics ([LSP](docs/lsp.md))
 - **Publication-ready** -- `typepython verify` performs structural publication checks by default, validates packaged wheel/sdist contents, and can opt into runtime import parity checks for trusted builds ([interop](docs/interop.md))
-- **Bundled stdlib stubs** -- typing data for Python 3.10-3.12 standard library, no external dependencies
+- **Bundled stdlib stubs** -- typing data for Python 3.10-3.14 standard library, no external dependencies
 
 ## Examples
 

{type_python-0.1.1 → type_python-0.2.0}/crates/typepython_checking/Cargo.toml

@@ -15,9 +15,11 @@ typepython-diagnostics = { path = "../typepython_diagnostics" }
 typepython-graph = { path = "../typepython_graph" }
 typepython-incremental = { path = "../typepython_incremental" }
 typepython-syntax = { path = "../typepython_syntax" }
+typepython-target = { path = "../typepython_target" }
 
 [dev-dependencies]
 criterion.workspace = true
+proptest.workspace = true
 
 [[bench]]
 name = "checker"

{type_python-0.1.1 → type_python-0.2.0}/crates/typepython_checking/benches/checker.rs

@@ -9,6 +9,7 @@ use typepython_binding::{
 use typepython_checking::{check, semantic_incremental_state_with_binding_metadata};
 use typepython_config::ImportFallback;
 use typepython_graph::{ModuleGraph, ModuleNode};
+use typepython_incremental::SnapshotMetadata;
 use typepython_syntax::{FunctionParam, SourceKind};
 
 fn param(name: &str, annotation: &str) -> FunctionParam {
@@ -351,6 +352,7 @@ fn bench_semantic_summary_medium(c: &mut Criterion) {
                 ImportFallback::Unknown,
                 None,
                 None,
+                SnapshotMetadata::default(),
             ))
         })
     });

type_python-0.2.0/crates/typepython_checking/proptest-regressions/tests/property_based.txt

@@ -0,0 +1,9 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 63f05c53e76f9d5ed8741ad0fae450971405542b1d44f8db482495e77fb3d217 # shrinks to value = Array([Array([Set([Int(1)]), Value(Bool(true))])])
+cc c738f0bc3ddd45e512f67449dd110d139d7e9db80de0ced95078fe9e09c59f4a # shrinks to value = Object([("a", Set([Bool(false)]))])
+cc c9862c46d0d8a51f9976bca7b6d6c8fd11f3c2eb3ee20f8f1dd0f47b978fc223 # shrinks to value = Set([Bool(false)])

{type_python-0.1.1 → type_python-0.2.0}/crates/typepython_checking/src/lib.rs

@@ -26,11 +26,12 @@ use typepython_config::{DiagnosticLevel, ImportFallback};
 use typepython_diagnostics::{Diagnostic, DiagnosticReport, Span, SuggestionApplicability};
 use typepython_graph::ModuleGraph;
 use typepython_incremental::{
-    IncrementalState, ModuleSolverFacts, PublicSummary, SealedRootSummary,
+    IncrementalState, ModuleSolverFacts, PublicSummary, SealedRootSummary, SnapshotMetadata,
     SummaryCallableSignature, SummaryDeclarationFact, SummaryExport, SummaryImportSymbolTarget,
     SummaryImportTarget, SummarySignatureParam, SummaryTypeParam, snapshot_with_summaries,
 };
 use typepython_syntax::SourceKind;
+use typepython_target::{RuntimeFeature, RuntimeTypingForm, RuntimeTypingSemantics};
 mod assignments;
 mod calls;
 mod declaration_semantics;
@@ -539,6 +540,7 @@ pub fn semantic_incremental_state_with_binding_metadata(
     import_fallback: ImportFallback,
     source_overrides: Option<&BTreeMap<String, String>>,
     stdlib_snapshot: Option<String>,
+    metadata: SnapshotMetadata,
 ) -> IncrementalState {
     let bound_surface_facts = binding_surface_facts_by_module(bindings);
     let context = CheckerContext::new_with_bound_surface_facts(
@@ -549,10 +551,14 @@ pub fn semantic_incremental_state_with_binding_metadata(
     );
     let summaries =
         graph.nodes.iter().map(|node| semantic_public_summary(&context, node)).collect();
-    snapshot_with_summaries(summaries, stdlib_snapshot)
+    snapshot_with_summaries(summaries, stdlib_snapshot, metadata)
 }
 
 #[must_use]
+#[expect(
+    clippy::too_many_arguments,
+    reason = "incremental summary reuse threads build context and summary state together"
+)]
 pub fn semantic_incremental_state_with_reused_summaries(
     graph: &ModuleGraph,
     bindings: &[BindingTable],
@@ -561,6 +567,7 @@ pub fn semantic_incremental_state_with_reused_summaries(
     previous_summaries: &[PublicSummary],
     summary_rebuild_modules: &BTreeSet<String>,
     stdlib_snapshot: Option<String>,
+    metadata: SnapshotMetadata,
 ) -> IncrementalState {
     let bound_surface_facts = binding_surface_facts_by_module(bindings);
     let context = CheckerContext::new_with_bound_surface_facts(
@@ -589,7 +596,7 @@ pub fn semantic_incremental_state_with_reused_summaries(
             }
         })
         .collect();
-    snapshot_with_summaries(summaries, stdlib_snapshot)
+    snapshot_with_summaries(summaries, stdlib_snapshot, metadata)
 }
 
 #[must_use]
@@ -847,19 +854,139 @@ fn semantic_summary_export(
             declaration.callable_signature().map(summary_callable_signature_from_bound)
         });
     let exported_type = semantic_exported_type(node, declaration, &semantics);
+    let required_runtime_features = required_runtime_features_for_export(
+        declaration,
+        declaration_signature.as_ref(),
+        exported_type.as_deref(),
+    );
     SummaryExport {
         name: declaration.name.clone(),
         kind: summary_kind_string(declaration),
         type_repr: exported_type.clone().unwrap_or_else(|| declaration.name.clone()),
         type_expr: exported_type.as_deref().and_then(TypeExpr::parse),
-        declaration_signature,
+        declaration_signature: declaration_signature.clone(),
         exported_type,
         exported_type_expr: declaration_exported_type_expr(declaration, &semantics),
         type_params: declaration.type_params.iter().map(summary_type_param).collect(),
+        runtime_semantics: summary_runtime_semantics(node.module_kind, declaration),
+        required_runtime_features,
         public: !declaration.name.starts_with('_'),
     }
 }
 
+fn summary_runtime_semantics(
+    module_kind: SourceKind,
+    declaration: &Declaration,
+) -> Option<RuntimeTypingSemantics> {
+    if module_kind != SourceKind::Python {
+        return None;
+    }
+    match declaration.kind {
+        DeclarationKind::TypeAlias => Some(RuntimeTypingSemantics {
+            form: RuntimeTypingForm::TypeAliasType,
+            type_param_names: declaration
+                .type_params
+                .iter()
+                .map(|type_param| type_param.name.clone())
+                .collect(),
+            annotation_scope_owner: Some(declaration.name.clone()),
+            lazy_alias_value: true,
+            local_type_params_hidden_from_globals: true,
+            required_features: runtime_semantic_features(declaration, true),
+        }),
+        DeclarationKind::Class if !declaration.type_params.is_empty() => {
+            Some(RuntimeTypingSemantics {
+                form: RuntimeTypingForm::NativeGenericClass,
+                type_param_names: declaration
+                    .type_params
+                    .iter()
+                    .map(|type_param| type_param.name.clone())
+                    .collect(),
+                annotation_scope_owner: Some(declaration.name.clone()),
+                lazy_alias_value: false,
+                local_type_params_hidden_from_globals: true,
+                required_features: runtime_semantic_features(declaration, false),
+            })
+        }
+        DeclarationKind::Function | DeclarationKind::Overload
+            if !declaration.type_params.is_empty() =>
+        {
+            Some(RuntimeTypingSemantics {
+                form: RuntimeTypingForm::NativeGenericFunction,
+                type_param_names: declaration
+                    .type_params
+                    .iter()
+                    .map(|type_param| type_param.name.clone())
+                    .collect(),
+                annotation_scope_owner: Some(declaration.name.clone()),
+                lazy_alias_value: false,
+                local_type_params_hidden_from_globals: true,
+                required_features: runtime_semantic_features(declaration, false),
+            })
+        }
+        _ => None,
+    }
+}
+
+fn runtime_semantic_features(declaration: &Declaration, is_alias: bool) -> Vec<RuntimeFeature> {
+    let mut features = Vec::new();
+    if is_alias {
+        features.push(RuntimeFeature::TypeStmt);
+    }
+    if !declaration.type_params.is_empty() {
+        features.push(RuntimeFeature::InlineTypeParams);
+    }
+    if declaration.type_params.iter().any(|type_param| type_param.default.is_some()) {
+        features.push(RuntimeFeature::GenericDefaults);
+    }
+    features
+}
+
+fn required_runtime_features_for_export(
+    declaration: &Declaration,
+    declaration_signature: Option<&SummaryCallableSignature>,
+    exported_type: Option<&str>,
+) -> Vec<String> {
+    let mut features = BTreeSet::<String>::new();
+    if !declaration.type_params.is_empty() {
+        features.insert(String::from("inline_type_params"));
+        if declaration.type_params.iter().any(|type_param| type_param.default.is_some()) {
+            features.insert(String::from("generic_defaults"));
+        }
+        if declaration.kind == DeclarationKind::TypeAlias {
+            features.insert(String::from("type_stmt"));
+        }
+    }
+
+    if let Some(exported_type) = exported_type {
+        extend_runtime_features_from_type_text(&mut features, exported_type);
+    }
+    if let Some(signature) = declaration_signature {
+        if let Some(returns) = &signature.returns {
+            extend_runtime_features_from_type_text(&mut features, returns);
+        }
+        for param in &signature.params {
+            if let Some(annotation) = &param.annotation {
+                extend_runtime_features_from_type_text(&mut features, annotation);
+            }
+        }
+    }
+
+    features.into_iter().collect()
+}
+
+fn extend_runtime_features_from_type_text(features: &mut BTreeSet<String>, text: &str) {
+    if text.contains("TypeIs[") {
+        features.insert(String::from("typing_type_is"));
+    }
+    if text.contains("ReadOnly[") {
+        features.insert(String::from("typing_readonly"));
+    }
+    if text == "NoDefault" || text.contains("NoDefault[") {
+        features.insert(String::from("typing_no_default"));
+    }
+}
+
 fn semantic_declaration_fact(
     context: &CheckerContext<'_>,
     declaration: &Declaration,
@@ -1018,9 +1145,22 @@ fn summary_signature_param(
 
 fn summary_type_param(type_param: &typepython_binding::GenericTypeParam) -> SummaryTypeParam {
     SummaryTypeParam {
+        kind: Some(match type_param.kind {
+            typepython_binding::GenericTypeParamKind::TypeVar => String::from("typevar"),
+            typepython_binding::GenericTypeParamKind::ParamSpec => String::from("paramspec"),
+            typepython_binding::GenericTypeParamKind::TypeVarTuple => String::from("typevartuple"),
+        }),
         name: type_param.name.clone(),
         bound: type_param.rendered_bound(),
         bound_expr: type_param.bound_expr.as_ref().map(|expr| expr.expr.clone()),
+        constraints: type_param.rendered_constraints(),
+        constraint_exprs: type_param
+            .constraint_exprs
+            .iter()
+            .map(|expr| expr.expr.clone())
+            .collect(),
+        default: type_param.rendered_default(),
+        default_expr: type_param.default_expr.as_ref().map(|expr| expr.expr.clone()),
     }
 }
 

{type_python-0.1.1 → type_python-0.2.0}/crates/typepython_checking/src/tests/advanced.rs

@@ -8674,6 +8674,18 @@ fn check_reports_dict_keyword_expansion_without_kwargs() {
     assert!(rendered.contains("cannot expand `**dict[str, int]` without `**kwargs`"));
 }
 
+#[test]
+fn check_reports_dict_literal_expansion_assignment_type_mismatch() {
+    let result = check_temp_typepython_source(
+        "extra: dict[str, str] = {\"name\": \"Ada\"}\npayload: dict[str, int] = {**extra}\n",
+    );
+
+    let rendered = result.diagnostics.as_text();
+    assert!(rendered.contains("TPY4001"));
+    assert!(rendered.contains("dict[str, int]"));
+    assert!(rendered.contains("dict[str, str]"));
+}
+
 #[test]
 fn check_accepts_closed_typed_dict_keyword_expansion_callsite() {
     let result = check_temp_typepython_source(

{type_python-0.1.1 → type_python-0.2.0}/crates/typepython_checking/src/tests/mod.rs

@@ -125,6 +125,7 @@ fn semantic_incremental_state_reuses_unchanged_public_summaries() {
         ImportFallback::Unknown,
         None,
         None,
+        typepython_incremental::SnapshotMetadata::default(),
     );
     let mut previous_summaries = baseline.summaries.clone();
     let sentinel_summary = {
@@ -152,6 +153,7 @@ fn semantic_incremental_state_reuses_unchanged_public_summaries() {
         &previous_summaries,
         &BTreeSet::from([String::from("app.a")]),
         None,
+        typepython_incremental::SnapshotMetadata::default(),
     );
 
     let reused_b = rebuilt
@@ -173,6 +175,130 @@ fn semantic_incremental_state_reuses_unchanged_public_summaries() {
     let _ = fs::remove_dir_all(&root);
 }
 
+#[test]
+fn semantic_incremental_summary_preserves_native_runtime_feature_markers() {
+    let root = create_temp_typepython_root();
+    let path = root.join("app.py");
+    let source_text = "type Pair[T = int] = tuple[T, T]\n\nclass Box[T = int]:\n    value: T\n\ndef first[T = int](value: T = 1) -> T:\n    return value\n";
+    fs::write(&path, source_text).expect("temp source should be written");
+
+    let tree = parse_with_options(
+        SourceFile {
+            path,
+            kind: SourceKind::Python,
+            logical_module: String::from("app"),
+            text: source_text.to_owned(),
+        },
+        ParseOptions::default(),
+    );
+    let bindings = vec![bind(&tree)];
+    let graph = build(&bindings);
+    let summary = semantic_incremental_state_with_binding_metadata(
+        &graph,
+        &bindings,
+        ImportFallback::Unknown,
+        None,
+        None,
+        typepython_incremental::SnapshotMetadata::default(),
+    )
+    .summaries
+    .into_iter()
+    .find(|summary| summary.module == "app")
+    .expect("summary should exist");
+
+    let pair = summary
+        .exports
+        .iter()
+        .find(|export| export.name == "Pair")
+        .expect("Pair export should exist");
+    let box_export = summary
+        .exports
+        .iter()
+        .find(|export| export.name == "Box")
+        .expect("Box export should exist");
+    let first = summary
+        .exports
+        .iter()
+        .find(|export| export.name == "first")
+        .expect("first export should exist");
+
+    assert!(pair.required_runtime_features.contains(&String::from("type_stmt")));
+    assert!(pair.required_runtime_features.contains(&String::from("inline_type_params")));
+    assert!(pair.required_runtime_features.contains(&String::from("generic_defaults")));
+    assert_eq!(
+        pair.runtime_semantics.as_ref().map(|semantics| semantics.form),
+        Some(typepython_target::RuntimeTypingForm::TypeAliasType)
+    );
+    assert!(box_export.required_runtime_features.contains(&String::from("inline_type_params")));
+    assert!(box_export.required_runtime_features.contains(&String::from("generic_defaults")));
+    assert_eq!(
+        box_export.runtime_semantics.as_ref().map(|semantics| semantics.form),
+        Some(typepython_target::RuntimeTypingForm::NativeGenericClass)
+    );
+    assert!(first.required_runtime_features.contains(&String::from("inline_type_params")));
+    assert!(first.required_runtime_features.contains(&String::from("generic_defaults")));
+    assert_eq!(
+        first.runtime_semantics.as_ref().map(|semantics| semantics.form),
+        Some(typepython_target::RuntimeTypingForm::NativeGenericFunction)
+    );
+
+    let _ = fs::remove_dir_all(&root);
+}
+
+#[test]
+fn semantic_incremental_summary_marks_runtime_sensitive_typing_surface() {
+    let root = create_temp_typepython_root();
+    let path = root.join("app.py");
+    let source_text = "from typing import NoDefault, ReadOnly, TypeIs\n\ntype Wrapped[T = int] = ReadOnly[T]\nmarker: NoDefault\n\ndef accepts(value: object) -> TypeIs[int]:\n    return isinstance(value, int)\n";
+    fs::write(&path, source_text).expect("temp source should be written");
+
+    let tree = parse_with_options(
+        SourceFile {
+            path,
+            kind: SourceKind::Python,
+            logical_module: String::from("app"),
+            text: source_text.to_owned(),
+        },
+        ParseOptions::default(),
+    );
+    let bindings = vec![bind(&tree)];
+    let graph = build(&bindings);
+    let summary = semantic_incremental_state_with_binding_metadata(
+        &graph,
+        &bindings,
+        ImportFallback::Unknown,
+        None,
+        None,
+        typepython_incremental::SnapshotMetadata::default(),
+    )
+    .summaries
+    .into_iter()
+    .find(|summary| summary.module == "app")
+    .expect("summary should exist");
+
+    let wrapped = summary
+        .exports
+        .iter()
+        .find(|export| export.name == "Wrapped")
+        .expect("Wrapped export should exist");
+    let marker = summary
+        .exports
+        .iter()
+        .find(|export| export.name == "marker")
+        .expect("marker export should exist");
+    let accepts = summary
+        .exports
+        .iter()
+        .find(|export| export.name == "accepts")
+        .expect("accepts export should exist");
+
+    assert!(wrapped.required_runtime_features.contains(&String::from("typing_readonly")));
+    assert!(marker.required_runtime_features.contains(&String::from("typing_no_default")));
+    assert!(accepts.required_runtime_features.contains(&String::from("typing_type_is")));
+
+    let _ = fs::remove_dir_all(&root);
+}
+
 #[test]
 fn check_propagates_generic_owner_arguments_into_member_reads() {
     let diagnostics = check_temp_typepython_source(
@@ -668,5 +794,6 @@ pub(super) fn type_relation_node_with_base_child() -> ModuleNode {
 mod advanced;
 mod advanced_generics;
 mod calls;
+mod property_based;
 mod semantic;
 mod typed_dict;