snowflake-code-unit-registry 0.4.3__tar.gz → 0.4.10__tar.gz

{snowflake_code_unit_registry-0.4.3 → snowflake_code_unit_registry-0.4.10}/Cargo.lock

@@ -1192,9 +1192,9 @@ dependencies = [
 
 [[package]]
 name = "jsonschema"
-version = "0.44.1"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f98b64a413c93a1b413dfbaf973b78d271648b9cae50b10302ad88af78991672"
+checksum = "6f29616f6e19415398eb186964fb7cbbeef572c79bede3622a8277667924bbe3"
 dependencies = [
  "ahash",
  "bytecount",
@@ -1852,9 +1852,9 @@ dependencies = [
 
 [[package]]
 name = "referencing"
-version = "0.44.1"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22952642836711d7a730d23a4dfb0d732e75a85e4c4f5704266d9c8fac278ff1"
+checksum = "b8a618c14f8ba29d8193bb55e2bf13e4fb2b1115313ecb7ae94b43100c7ac7d5"
 dependencies = [
  "ahash",
  "fluent-uri",
@@ -1904,6 +1904,16 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "regress"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07948de9abc2e83adbeb7543c061a5ddaf7d944afcafbdd6e6b39aeacd40504b"
+dependencies = [
+ "hashbrown 0.16.1",
+ "memchr",
+]
+
 [[package]]
 name = "reqwest"
 version = "0.13.2"
@@ -2067,7 +2077,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-core"
-version = "0.4.3"
+version = "0.4.10"
 dependencies = [
  "chrono",
  "err_code",
@@ -2075,7 +2085,7 @@ dependencies = [
  "jsonschema",
  "prettyplease",
  "rayon",
- "regress",
+ "regress 0.11.0",
  "schemars",
  "serde",
  "serde_json",
@@ -2083,6 +2093,7 @@ dependencies = [
  "strum",
  "syn",
  "tempfile",
+ "test-case",
  "thiserror 2.0.18",
  "typify",
  "uuid",
@@ -2091,7 +2102,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-csharp"
-version = "0.4.3"
+version = "0.4.10"
 dependencies = [
  "interoptopus",
  "interoptopus_backend_csharp",
@@ -2102,7 +2113,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-node"
-version = "0.4.3"
+version = "0.4.10"
 dependencies = [
  "napi",
  "napi-build",
@@ -2114,7 +2125,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-python"
-version = "0.4.3"
+version = "0.4.10"
 dependencies = [
  "pyo3",
  "pythonize",
@@ -2417,9 +2428,9 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tempfile"
-version = "3.26.0"
+version = "3.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82a72c767771b47409d2345987fda8628641887d5466101319899796367354a0"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
  "getrandom 0.4.2",
@@ -2450,6 +2461,39 @@ dependencies = [
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "test-case"
+version = "3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb2550dd13afcd286853192af8601920d959b14c401fcece38071d53bf0768a8"
+dependencies = [
+ "test-case-macros",
+]
+
+[[package]]
+name = "test-case-core"
+version = "3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adcb7fd841cd518e279be3d5a3eb0636409487998a4aff22f3de87b81e88384f"
+dependencies = [
+ "cfg-if",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "test-case-macros"
+version = "3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c89e72a01ed4c579669add59014b9a524d609c0c88c6a585ce37485879f6ffb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "test-case-core",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -2633,7 +2677,7 @@ dependencies = [
  "log",
  "proc-macro2",
  "quote",
- "regress",
+ "regress 0.10.5",
  "schemars",
  "semver",
  "serde",

{snowflake_code_unit_registry-0.4.3 → snowflake_code_unit_registry-0.4.10}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/scai-state-core", "crates/scai-state-python"]
 
 [workspace.package]
-version = "0.4.3"
+version = "0.4.10"
 edition = "2021"
 license = "SEE LICENSE IN LICENSE"
 repository = "https://github.com/snowflake-eng/scai-state"

{snowflake_code_unit_registry-0.4.3 → snowflake_code_unit_registry-0.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-code-unit-registry
-Version: 0.4.3
+Version: 0.4.10
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{snowflake_code_unit_registry-0.4.3 → snowflake_code_unit_registry-0.4.10}/crates/scai-state-core/Cargo.toml

@@ -14,10 +14,11 @@ strum.workspace = true
 uuid.workspace = true
 fs2.workspace = true
 sqlparser.workspace = true
-regress = "0.10"
+regress = "0.11"
 chrono = { version = "0.4", features = ["serde"] }
 xxhash-rust = { version = "0.8", features = ["xxh3"] }
 rayon = "1.10"
+jsonschema = "0.45"
 
 [build-dependencies]
 typify = "0.6"
@@ -28,4 +29,4 @@ prettyplease = "0.2"
 
 [dev-dependencies]
 tempfile = "3"
-jsonschema = "0.44"
+test-case = "3"

{snowflake_code_unit_registry-0.4.3 → snowflake_code_unit_registry-0.4.10}/crates/scai-state-core/build.rs

@@ -1,6 +1,104 @@
 use std::fs;
 use std::path::Path;
 
+const DEFINITION_REF_PREFIX: &str = "#/definitions/";
+
+// ── Schema Document ──────────────────────────────────────────────────────
+
+type JsonObject = serde_json::Map<String, serde_json::Value>;
+
+/// Parsed JSON Schema with centralized navigation helpers.
+/// Created once and shared across all generators so the schema is parsed
+/// and its `definitions` map resolved in a single place.
+struct SchemaDoc {
+    root: serde_json::Value,
+}
+
+impl SchemaDoc {
+    fn from_str(text: &str) -> Self {
+        let root: serde_json::Value =
+            serde_json::from_str(text).expect("Failed to parse schema JSON");
+        SchemaDoc { root }
+    }
+
+    fn definitions(&self) -> Option<&JsonObject> {
+        self.root.get("definitions").and_then(|d| d.as_object())
+    }
+
+    /// Resolve a `$ref` node to its target definition.
+    /// Non-ref nodes pass through unchanged.
+    /// Panics on malformed or unresolvable refs — those are schema-authoring
+    /// errors that should fail the build loudly.
+    fn resolve<'a>(&'a self, node: &'a serde_json::Value) -> &'a serde_json::Value {
+        let Some(ref_path) = node.get("$ref").and_then(|r| r.as_str()) else {
+            return node;
+        };
+        let def_name = ref_path
+            .strip_prefix(DEFINITION_REF_PREFIX)
+            .unwrap_or_else(|| panic!("Unsupported $ref format: {ref_path}"));
+        self.definitions()
+            .and_then(|d| d.get(def_name))
+            .unwrap_or_else(|| panic!("Unresolved $ref: {ref_path}"))
+    }
+
+    /// Sorted property entries of a JSON Schema object node.
+    /// Returns an empty vec for non-objects or objects without a `properties` key.
+    fn sorted_properties<'a>(
+        &'a self,
+        node: &'a serde_json::Value,
+    ) -> Vec<(&'a str, &'a serde_json::Value)> {
+        let Some(properties) = node.get("properties").and_then(|p| p.as_object()) else {
+            return Vec::new();
+        };
+        let mut entries: Vec<(&str, &serde_json::Value)> =
+            properties.iter().map(|(k, v)| (k.as_str(), v)).collect();
+        entries.sort_by(|(a, _), (b, _)| a.cmp(b));
+        entries
+    }
+
+    /// Schema `type` keyword, defaulting to `"object"` when absent.
+    fn node_type<'a>(&self, node: &'a serde_json::Value) -> &'a str {
+        node.get("type")
+            .and_then(|t| t.as_str())
+            .unwrap_or("object")
+    }
+
+    fn root_properties(&self) -> Vec<(&str, &serde_json::Value)> {
+        self.sorted_properties(&self.root)
+    }
+}
+
+// ── Shared Object Tree Walker ────────────────────────────────────────────
+
+/// Recursively visit every property of every reachable object node in the
+/// schema, resolving `$ref` along the way.  Arrays and scalars are
+/// intentionally skipped — the generated path constants are consumed by
+/// object-only JSON navigation helpers that do not model array indices.
+///
+/// The `visit` callback receives the full segment path and the *resolved*
+/// property value for every property of every reachable object.
+fn walk_object_tree(
+    doc: &SchemaDoc,
+    current_path: &[String],
+    node: &serde_json::Value,
+    visit: &mut impl FnMut(&[String], &serde_json::Value),
+) {
+    let node = doc.resolve(node);
+    if doc.node_type(node) != "object" {
+        return;
+    }
+
+    for (name, raw_child) in doc.sorted_properties(node) {
+        let child = doc.resolve(raw_child);
+        let mut child_path = current_path.to_vec();
+        child_path.push(name.to_string());
+        visit(&child_path, child);
+        walk_object_tree(doc, &child_path, child, visit);
+    }
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────
+
 fn main() {
     println!("cargo:rerun-if-changed=./schemas/code-unit.schema.json");
     println!("cargo:rerun-if-changed=./schemas/query-reference.tmpl");
@@ -23,29 +121,37 @@ fn main() {
     let schema_content =
         fs::read_to_string(schema_path).expect("Failed to read code-unit.schema.json");
 
+    // Typify needs its own parse (schemars::schema::RootSchema), so it
+    // still receives the raw string.
     let generated_code = generate_with_typify(&schema_content);
+    write_generated(out_dir, "types.rs", &generated_code, "types");
 
-    let output_path = out_dir.join("types.rs");
-    fs::write(&output_path, &generated_code).expect("Failed to write generated types");
-
-    println!("cargo:warning=Generated types to {:?}", output_path);
+    let doc = SchemaDoc::from_str(&schema_content);
 
-    let query_ref_code = generate_query_reference(&schema_content);
-    let query_ref_path = out_dir.join("query_reference.rs");
-    fs::write(&query_ref_path, &query_ref_code).expect("Failed to write query reference");
+    let query_template = fs::read_to_string("./schemas/query-reference.tmpl")
+        .expect("Failed to read schemas/query-reference.tmpl");
+    let query_rs_template = fs::read_to_string("./schemas/query-reference.rs.tmpl")
+        .expect("Failed to read schemas/query-reference.rs.tmpl");
 
-    println!(
-        "cargo:warning=Generated query reference to {:?}",
-        query_ref_path
+    write_generated(
+        out_dir,
+        "query_reference.rs",
+        &generate_query_reference(&doc, &query_template, &query_rs_template),
+        "query reference",
     );
 
-    let updated_at_code = generate_updated_at_paths(&schema_content);
-    let updated_at_path = out_dir.join("updated_at_paths.rs");
-    fs::write(&updated_at_path, &updated_at_code).expect("Failed to write updated_at_paths");
+    write_generated(
+        out_dir,
+        "updated_at_paths.rs",
+        &generate_updated_at_paths(&doc),
+        "updated_at_paths",
+    );
 
-    println!(
-        "cargo:warning=Generated updated_at_paths to {:?}",
-        updated_at_path
+    write_generated(
+        out_dir,
+        "file_path_fields.rs",
+        &generate_file_path_fields(&doc),
+        "file_path_fields",
     );
 
     check_sibling_generated_files();
@@ -72,6 +178,25 @@ fn check_sibling_generated_files() {
     }
 }
 
+fn write_generated(out_dir: &Path, filename: &str, code: &str, label: &str) {
+    let output_path = out_dir.join(filename);
+    fs::write(&output_path, code).unwrap_or_else(|_| panic!("Failed to write {}", label));
+    println!("cargo:warning=Generated {} to {:?}", label, output_path);
+}
+
+fn render_path_constant(const_name: &str, comment: &str, paths: &[Vec<String>]) -> String {
+    let mut code = String::from("// AUTO-GENERATED FROM JSON SCHEMA - DO NOT EDIT MANUALLY\n");
+    code.push_str(comment);
+    code.push_str("\n\n");
+    code.push_str(&format!("pub const {const_name}: &[&[&str]] = &[\n"));
+    for path in paths {
+        let segments: Vec<String> = path.iter().map(|s| format!("\"{}\"", s)).collect();
+        code.push_str(&format!("    &[{}],\n", segments.join(", ")));
+    }
+    code.push_str("];\n");
+    code
+}
+
 // ── Query Reference Generator ────────────────────────────────────────────
 
 /// A flattened field descriptor extracted from the JSON Schema.
@@ -84,30 +209,19 @@ struct FieldInfo {
 
 /// Walk the JSON Schema and produce a Rust source file containing
 /// `pub const QUERY_REFERENCE: &str` with the full flattened field reference.
-fn generate_query_reference(schema_content: &str) -> String {
-    let schema: serde_json::Value =
-        serde_json::from_str(schema_content).expect("Failed to parse schema JSON");
-    let definitions = schema.get("definitions").and_then(|d| d.as_object());
-
+///
+/// This generator has its own recursive traversal (`collect_fields`) because
+/// it handles arrays, enums, and `x-query-help` exclusion — none of which
+/// apply to the path-oriented generators that share `walk_object_tree`.
+fn generate_query_reference(doc: &SchemaDoc, template: &str, rs_template: &str) -> String {
     let mut fields = Vec::new();
-    if let Some(properties) = schema.get("properties").and_then(|p| p.as_object()) {
-        let mut sorted_keys: Vec<&String> = properties.keys().collect();
-        sorted_keys.sort();
-        for name in sorted_keys {
-            let prop = &properties[name];
-            collect_fields(&mut fields, name, prop, definitions);
-        }
+    for (name, prop) in doc.root_properties() {
+        collect_fields(&mut fields, name, prop, doc);
     }
 
     let fields_table = format_fields_table(&fields);
-
-    let template = fs::read_to_string("./schemas/query-reference.tmpl")
-        .expect("Failed to read schemas/query-reference.tmpl");
     let reference = template.replace("{fields_table}", &fields_table);
-
     let ref_literal = format!("r#\"{}\"#", reference);
-    let rs_template = fs::read_to_string("./schemas/query-reference.rs.tmpl")
-        .expect("Failed to read schemas/query-reference.rs.tmpl");
     rs_template.replace("{ref_literal}", &ref_literal)
 }
 
@@ -124,26 +238,15 @@ fn collect_fields(
     fields: &mut Vec<FieldInfo>,
     prefix: &str,
     prop: &serde_json::Value,
-    definitions: Option<&serde_json::Map<String, serde_json::Value>>,
+    doc: &SchemaDoc,
 ) {
     if is_excluded(prop) {
         return;
     }
 
-    // Resolve $ref
-    if let Some(ref_path) = prop.get("$ref").and_then(|r| r.as_str()) {
-        if let Some(def_name) = ref_path.strip_prefix("#/definitions/") {
-            if let Some(resolved) = definitions.and_then(|d| d.get(def_name)) {
-                collect_fields(fields, prefix, resolved, definitions);
-            }
-        }
-        return;
-    }
+    let prop = doc.resolve(prop);
 
-    let type_str = prop
-        .get("type")
-        .and_then(|t| t.as_str())
-        .unwrap_or("object");
+    let type_str = doc.node_type(prop);
     let description = prop
         .get("description")
         .and_then(|d| d.as_str())
@@ -152,34 +255,21 @@ fn collect_fields(
 
     match type_str {
         "object" => {
-            if let Some(sub_props) = prop.get("properties").and_then(|p| p.as_object()) {
-                // Emit the object node itself (useful for IS NULL checks)
-                fields.push(FieldInfo {
-                    path: prefix.to_string(),
-                    type_name: "object".to_string(),
-                    enum_values: None,
-                    description: description.clone(),
-                });
-                let mut sorted_keys: Vec<&String> = sub_props.keys().collect();
-                sorted_keys.sort();
-                for name in sorted_keys {
-                    let sub_prop = &sub_props[name];
-                    let child_path = format!("{}.{}", prefix, name);
-                    collect_fields(fields, &child_path, sub_prop, definitions);
-                }
-            } else {
-                fields.push(FieldInfo {
-                    path: prefix.to_string(),
-                    type_name: "object".to_string(),
-                    enum_values: None,
-                    description,
-                });
+            fields.push(FieldInfo {
+                path: prefix.to_string(),
+                type_name: "object".to_string(),
+                enum_values: None,
+                description,
+            });
+            for (name, sub_prop) in doc.sorted_properties(prop) {
+                let child_path = format!("{}.{}", prefix, name);
+                collect_fields(fields, &child_path, sub_prop, doc);
             }
         }
         "array" => {
             let item_desc = prop
                 .get("items")
-                .and_then(|i| describe_array_items(i, definitions))
+                .map(|i| describe_array_items(i, doc))
                 .unwrap_or_default();
             let full_desc = if description.is_empty() {
                 item_desc
@@ -220,32 +310,22 @@ fn collect_fields(
 }
 
 /// Produce a short description of array item shapes (for display only).
-fn describe_array_items(
-    items: &serde_json::Value,
-    definitions: Option<&serde_json::Map<String, serde_json::Value>>,
-) -> Option<String> {
-    // Resolve $ref on items
-    let resolved = if let Some(ref_path) = items.get("$ref").and_then(|r| r.as_str()) {
-        ref_path
-            .strip_prefix("#/definitions/")
-            .and_then(|name| definitions.and_then(|d| d.get(name)))
-            .unwrap_or(items)
-    } else {
-        items
-    };
+fn describe_array_items(items: &serde_json::Value, doc: &SchemaDoc) -> String {
+    let resolved = doc.resolve(items);
 
     match resolved.get("type").and_then(|t| t.as_str()) {
-        Some("string") => Some("string".to_string()),
+        Some("string") => "string".to_string(),
         Some("object") => {
-            if let Some(props) = resolved.get("properties").and_then(|p| p.as_object()) {
-                let keys: Vec<&str> = props.keys().map(|k| k.as_str()).collect();
-                Some(format!("{{{}}}", keys.join(", ")))
+            let props = doc.sorted_properties(resolved);
+            if props.is_empty() {
+                "object".to_string()
             } else {
-                Some("object".to_string())
+                let keys: Vec<&str> = props.iter().map(|(k, _)| *k).collect();
+                format!("{{{}}}", keys.join(", "))
             }
         }
-        Some(t) => Some(t.to_string()),
-        None => None,
+        Some(t) => t.to_string(),
+        None => String::new(),
     }
 }
 
@@ -286,87 +366,56 @@ fn format_fields_table(fields: &[FieldInfo]) -> String {
 
 /// Walk the JSON Schema and find all parent paths of `updatedAt` properties.
 /// Generates a Rust source file with a constant array of those paths.
-fn generate_updated_at_paths(schema_content: &str) -> String {
-    let schema: serde_json::Value =
-        serde_json::from_str(schema_content).expect("Failed to parse schema JSON");
-    let definitions = schema.get("definitions").and_then(|d| d.as_object());
-
+///
+/// Uses `walk_object_tree` and simply records the parent path (all segments
+/// except the last) whenever the walker visits a property named `updatedAt`.
+fn generate_updated_at_paths(doc: &SchemaDoc) -> String {
     let mut parent_paths: Vec<Vec<String>> = Vec::new();
-    if let Some(properties) = schema.get("properties").and_then(|p| p.as_object()) {
-        if properties.contains_key("updatedAt") {
-            parent_paths.push(vec![]);
-        }
-        for (name, prop) in properties {
-            if name == "updatedAt" {
-                continue;
-            }
-            collect_updated_at_parents(
-                &mut parent_paths,
-                std::slice::from_ref(name),
-                prop,
-                definitions,
-            );
+
+    walk_object_tree(doc, &[], &doc.root, &mut |path, _node| {
+        if path.last().map(|s| s.as_str()) == Some("updatedAt") {
+            parent_paths.push(path[..path.len() - 1].to_vec());
         }
-    }
+    });
 
     parent_paths.sort();
-
-    let mut code = String::from(
-        "// AUTO-GENERATED FROM JSON SCHEMA - DO NOT EDIT MANUALLY\n\
-         // Parent paths of all `updatedAt` properties in code-unit.schema.json\n\n",
-    );
-
-    code.push_str("pub const UPDATED_AT_PARENT_PATHS: &[&[&str]] = &[\n");
-    for path in &parent_paths {
-        let segments: Vec<String> = path.iter().map(|s| format!("\"{}\"", s)).collect();
-        code.push_str(&format!("    &[{}],\n", segments.join(", ")));
-    }
-    code.push_str("];\n");
-
-    code
+    render_path_constant(
+        "UPDATED_AT_PARENT_PATHS",
+        "// Parent paths of all `updatedAt` properties in code-unit.schema.json",
+        &parent_paths,
+    )
 }
 
-/// Recursively walk schema properties. When an `updatedAt` property is found,
-/// record the path to its parent object (all segments except the last).
-fn collect_updated_at_parents(
-    parents: &mut Vec<Vec<String>>,
-    current_path: &[String],
-    prop: &serde_json::Value,
-    definitions: Option<&serde_json::Map<String, serde_json::Value>>,
-) {
-    // Resolve $ref
-    if let Some(ref_path) = prop.get("$ref").and_then(|r| r.as_str()) {
-        if let Some(def_name) = ref_path.strip_prefix("#/definitions/") {
-            if let Some(resolved) = definitions.and_then(|d| d.get(def_name)) {
-                collect_updated_at_parents(parents, current_path, resolved, definitions);
-            }
-        }
-        return;
-    }
-
-    let type_str = prop
-        .get("type")
-        .and_then(|t| t.as_str())
-        .unwrap_or("object");
-
-    if type_str == "object" {
-        if let Some(sub_props) = prop.get("properties").and_then(|p| p.as_object()) {
-            if sub_props.contains_key("updatedAt") {
-                // current_path points to the parent object that contains updatedAt
-                parents.push(current_path.to_vec());
-            }
-            for (name, sub_prop) in sub_props {
-                if name == "updatedAt" {
-                    continue;
+// ── File Path Field Extraction ─────────────────────────────────────────────
+
+/// Walk the JSON Schema and find all string properties whose description
+/// starts with "Repo-root-relative".  Generates a constant array of
+/// segment paths.
+///
+/// Uses `walk_object_tree` and inspects each visited node.
+fn generate_file_path_fields(doc: &SchemaDoc) -> String {
+    let mut paths: Vec<Vec<String>> = Vec::new();
+
+    walk_object_tree(doc, &[], &doc.root, &mut |path, node| {
+        if doc.node_type(node) == "string" {
+            if let Some(desc) = node.get("description").and_then(|d| d.as_str()) {
+                if desc.starts_with("Repo-root-relative") {
+                    paths.push(path.to_vec());
                 }
-                let mut child_path = current_path.to_vec();
-                child_path.push(name.clone());
-                collect_updated_at_parents(parents, &child_path, sub_prop, definitions);
             }
         }
-    }
+    });
+
+    paths.sort();
+    render_path_constant(
+        "FILE_PATH_FIELDS",
+        "// Segment paths of all file path properties in code-unit.schema.json",
+        &paths,
+    )
 }
 
+// ── Typify Code Generation ───────────────────────────────────────────────
+
 fn generate_with_typify(schema: &str) -> String {
     use typify::{TypeSpace, TypeSpaceSettings};
 

{snowflake_code_unit_registry-0.4.3 → snowflake_code_unit_registry-0.4.10}/crates/scai-state-core/examples/code-unit.example.json

@@ -46,7 +46,7 @@
       "converterVersion": "3.1.0"
     },
     "aiVerification": {
-      "status": "reviewed",
+      "status": "completed",
       "convertedChecksum": "defa8dbc2f2c5915579ade9fdc6aef24"
     },
     "assessment": {