@alizarin/napi 2.0.0-alpha.91 → 2.0.0-alpha.94

package/Cargo.toml

@@ -16,6 +16,7 @@ napi = { version = "2", features = ["napi6", "serde-json"] }
 napi-derive = "2"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+uuid = { version = "1", features = ["v4", "v5"] }
 
 [build-dependencies]
 napi-build = "2"

package/__test__/index.mjs

@@ -345,7 +345,7 @@ describe('NapiPseudoValue property names', () => {
 
   // Create instance wrapper and load tiles
   const instanceWrapper = new NapiResourceInstanceWrapper(resource.resourceinstance.graph_id);
-  instanceWrapper.loadTilesFromResource(resource);
+  instanceWrapper.loadTilesFromResource(JSON.stringify(resource));
 
   // Get a PseudoList and PseudoValue
   const pseudoList = instanceWrapper.getValuesAtPath('basic_info.name');
@@ -433,13 +433,13 @@ describe('NapiResourceInstanceWrapper methods', () => {
 
   it('has setTileDataForNode method', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
     assert.equal(typeof wrapper.setTileDataForNode, 'function');
   });
 
   it('setTileDataForNode mutates tile data', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
 
     const tileIds = wrapper.getAllTileIds();
     assert.ok(tileIds.length > 0, 'should have tiles');
@@ -459,13 +459,13 @@ describe('NapiResourceInstanceWrapper methods', () => {
     assert.equal(typeof wrapper.tilesLoaded, 'function');
     assert.equal(wrapper.tilesLoaded(), false);
 
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
     assert.equal(wrapper.tilesLoaded(), true);
   });
 
   it('has toJson method', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
     assert.equal(typeof wrapper.toJson, 'function');
     // toJson requires populate() first; just verify the method exists
     // and that calling it without populate gives a meaningful error
@@ -481,7 +481,7 @@ describe('NapiResourceInstanceWrapper methods', () => {
 
   it('exportTilesJson returns valid JSON array of tiles', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
 
     const json = wrapper.exportTilesJson();
     assert.equal(typeof json, 'string');
@@ -499,7 +499,7 @@ describe('NapiResourceInstanceWrapper methods', () => {
 
   it('exportTilesJson reflects setTileDataForNode mutations', () => {
     const wrapper = new NapiResourceInstanceWrapper(graphId);
-    wrapper.loadTilesFromResource(resource);
+    wrapper.loadTilesFromResource(JSON.stringify(resource));
 
     const tileIds = wrapper.getAllTileIds();
     const tileId = tileIds[0];

package/index.d.ts

@@ -40,6 +40,28 @@ export declare function extensionResolveMarkers(datatype: string, tileData: any,
 export declare function hasExtensionHandler(datatype: string): boolean
 /** List all registered extension handler datatypes. */
 export declare function getRegisteredExtensionHandlers(): Array<string>
+/** Parse SKOS RDF/XML and return all collections as a JSON array. */
+export declare function parseSkosXml(xmlContent: string, baseUri: string): any
+/** Parse SKOS RDF/XML and return a single collection (the first one found). */
+export declare function parseSkosXmlToCollection(xmlContent: string, baseUri: string): any
+/**
+ * Build a mapping from node alias to collection ID based on graph definition.
+ *
+ * Equivalent to WASM's `buildAliasToCollectionMap`.
+ */
+export declare function buildAliasToCollectionMap(graphJson: string, resolvableDatatypes?: Array<string> | undefined | null, configKeys?: Array<string> | undefined | null): Record<string, string>
+/**
+ * Scan a JSON tree to find which collections are needed for resolution.
+ *
+ * Equivalent to WASM's `findNeededCollections`.
+ */
+export declare function findNeededCollections(treeJson: string, aliasToCollection: Record<string, string>): Array<string>
+/** Check if a string is a valid UUID. */
+export declare function isValidUuid(s: string): boolean
+/** Get the default resolvable datatypes (concept, concept-list). */
+export declare function getDefaultResolvableDatatypes(): Array<string>
+/** Get the default config keys for collection IDs. */
+export declare function getDefaultConfigKeys(): Array<string>
 /**
  * Import a prebuild/pkg directory: register graphs, load SKOS collections,
  * and load ontology configs.
@@ -58,6 +80,18 @@ export declare class NapiRdmCache {
   /** Load a single collection from JSON. */
   loadCollectionJson(jsonStr: string): void
   get collectionCount(): number
+  /** Check if a collection is already in the cache. */
+  hasCollection(collectionId: string): boolean
+  /** Add a collection from a JSON string of concepts. */
+  addCollectionFromJson(collectionId: string, jsonStr: string): void
+  /** Get the parent concept ID for a concept within a collection. */
+  getParentId(collectionId: string, conceptId: string): string | null
+  /** Remove a collection from the cache. */
+  removeCollection(collectionId: string): boolean
+  /** Clear all collections from the cache. */
+  clear(): void
+  /** Resolve labels to UUIDs using this cache for lookups. */
+  resolveLabels(treeJson: string, aliasToCollection: Record<string, string>, strict: boolean): any
 }
 export declare class NapiNodeConfigManager {
   constructor()
@@ -66,6 +100,33 @@ export declare class NapiNodeConfigManager {
   /** Build node configs from a NapiStaticGraph. */
   buildFromGraph(graph: NapiStaticGraph): void
 }
+export declare class NapiTileData {
+  has(key: string): boolean
+  get(key: string): any
+  set(key: string, value: any): void
+  delete(key: string): boolean
+  keys(): Array<string>
+}
+export declare class NapiStaticTile {
+  constructor(nodegroupId: string, tileid?: string | undefined | null, sortorder?: number | undefined | null, resourceinstanceId?: string | undefined | null, parenttileId?: string | undefined | null)
+  get data(): NapiTileData
+  /**
+   * Setter is a no-op — data is always accessed via the NapiTileData getter.
+   * Exists to prevent TypeError in strict mode when JS does
+   * `tile.data = tile.data || new Map()`.
+   */
+  set data(value: any)
+  get tileid(): string | null
+  set tileid(value?: string | undefined | null)
+  get nodegroupId(): string
+  get sortorder(): number | null
+  get resourceinstanceId(): string
+  get parenttileId(): string | null
+  set parenttileId(value?: string | undefined | null)
+  get provisionaledits(): any
+  /** Generate a tile ID if not already set. */
+  ensureId(): string
+}
 export declare class NapiPseudoValue {
   get node(): any
   get nodeId(): string | null
@@ -96,6 +157,12 @@ export declare class NapiPseudoValue {
   toSnapshot(): any
   /** Clear tile data */
   clear(): void
+  get tile(): NapiStaticTile | null
+  set tile(tile?: NapiStaticTile | undefined | null)
+  /** Get the inner PseudoValueCore wrapped as NapiPseudoValue. */
+  get inner(): NapiPseudoValue | null
+  /** Returns null — value is managed JS-side via _cachedValue. */
+  get value(): any
 }
 export declare class NapiPseudoList {
   get nodeAlias(): string
@@ -128,10 +195,15 @@ export declare class NapiValuesFromNodegroupResult {
 export declare class NapiResourceInstanceWrapper {
   /** Create a wrapper for a given graph (must be registered). */
   constructor(graphId: string)
-  /** Load tiles from a JSON array. */
-  loadTiles(tilesJs: any): void
-  /** Load tiles directly from a StaticResource JSON. */
-  loadTilesFromResource(resourceJs: any): void
+  /** Load tiles from a JSON string (single-pass deserialization). */
+  loadTiles(tilesJson: string): void
+  /** Load tiles directly from a StaticResource JSON string (single-pass deserialization). */
+  loadTilesFromResource(resourceJson: string): void
+  /**
+   * Load tiles directly from a NapiStaticResourceRegistry by resource ID.
+   * This avoids the JS round-trip of serializing tiles to JS and back.
+   */
+  loadFromRegistry(resourceId: string, registry: NapiStaticResourceRegistry): boolean
   /** Append tiles incrementally (for lazy loading). */
   appendTiles(tilesJs: any): void
   getTileCount(): number
@@ -169,6 +241,13 @@ export declare class NapiResourceInstanceWrapper {
   ensureNodegroup(allValuesJs: any, allNodegroupsJs: any, nodegroupId: string, addIfMissing: boolean, nodegroupPermissionsJs: any, doImpliedNodegroups: boolean): NapiEnsureNodegroupResult
   /** Build pseudo values from tiles for a specific nodegroup. */
   valuesFromResourceNodegroup(existingValuesJs: any, nodegroupTileIds: Array<string>, nodegroupId: string): NapiValuesFromNodegroupResult
+  /**
+   * Resolve a dot-separated path to its target node metadata without needing tiles.
+   *
+   * Returns { nodegroupId, isSingle, targetNodeId } — enough for the JS layer to
+   * lazy-load just that nodegroup's tiles before calling getValuesAtPath.
+   */
+  resolvePath(path: string): any
   /** Resolve a dot-separated path and return a PseudoList. */
   getValuesAtPath(path: string): NapiPseudoList
   /**

package/index.js

@@ -310,10 +310,12 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { NapiRdmCache, NapiNodeConfigManager, NapiPseudoValue, NapiPseudoList, NapiPopulateResult, NapiEnsureNodegroupResult, NapiValuesFromNodegroupResult, NapiResourceInstanceWrapper, NapiResourceModelWrapper, NapiPrebuildExporter, NapiStaticGraph, NapiStaticResourceRegistry, buildGraphFromCsvs, buildBusinessDataFromCsv, extensionCoerce, extensionRenderDisplay, extensionResolveMarkers, hasExtensionHandler, getRegisteredExtensionHandlers, importPrebuild } = nativeBinding
+const { NapiRdmCache, NapiNodeConfigManager, NapiTileData, NapiStaticTile, NapiPseudoValue, NapiPseudoList, NapiPopulateResult, NapiEnsureNodegroupResult, NapiValuesFromNodegroupResult, NapiResourceInstanceWrapper, NapiResourceModelWrapper, NapiPrebuildExporter, NapiStaticGraph, NapiStaticResourceRegistry, buildGraphFromCsvs, buildBusinessDataFromCsv, extensionCoerce, extensionRenderDisplay, extensionResolveMarkers, hasExtensionHandler, getRegisteredExtensionHandlers, parseSkosXml, parseSkosXmlToCollection, buildAliasToCollectionMap, findNeededCollections, isValidUuid, getDefaultResolvableDatatypes, getDefaultConfigKeys, importPrebuild } = nativeBinding
 
 module.exports.NapiRdmCache = NapiRdmCache
 module.exports.NapiNodeConfigManager = NapiNodeConfigManager
+module.exports.NapiTileData = NapiTileData
+module.exports.NapiStaticTile = NapiStaticTile
 module.exports.NapiPseudoValue = NapiPseudoValue
 module.exports.NapiPseudoList = NapiPseudoList
 module.exports.NapiPopulateResult = NapiPopulateResult
@@ -331,4 +333,11 @@ module.exports.extensionRenderDisplay = extensionRenderDisplay
 module.exports.extensionResolveMarkers = extensionResolveMarkers
 module.exports.hasExtensionHandler = hasExtensionHandler
 module.exports.getRegisteredExtensionHandlers = getRegisteredExtensionHandlers
+module.exports.parseSkosXml = parseSkosXml
+module.exports.parseSkosXmlToCollection = parseSkosXmlToCollection
+module.exports.buildAliasToCollectionMap = buildAliasToCollectionMap
+module.exports.findNeededCollections = findNeededCollections
+module.exports.isValidUuid = isValidUuid
+module.exports.getDefaultResolvableDatatypes = getDefaultResolvableDatatypes
+module.exports.getDefaultConfigKeys = getDefaultConfigKeys
 module.exports.importPrebuild = importPrebuild

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alizarin/napi",
-  "version": "2.0.0-alpha.91",
+  "version": "2.0.0-alpha.94",
   "license": "AGPL-3.0-or-later",
   "repository": {
     "type": "git",
@@ -30,8 +30,8 @@
     "@napi-rs/cli": "^2.18.0"
   },
   "optionalDependencies": {
-    "@alizarin/napi-win32-x64-msvc": "2.0.0-alpha.91",
-    "@alizarin/napi-darwin-x64": "2.0.0-alpha.91",
-    "@alizarin/napi-linux-x64-gnu": "2.0.0-alpha.91"
+    "@alizarin/napi-win32-x64-msvc": "2.0.0-alpha.94",
+    "@alizarin/napi-darwin-x64": "2.0.0-alpha.94",
+    "@alizarin/napi-linux-x64-gnu": "2.0.0-alpha.94"
   }
 }

package/src/instance_wrapper_napi.rs

@@ -4,7 +4,7 @@
 /// the TypeScript ViewModel layer (ResourceInstanceWrapper / PseudoValue / PseudoList)
 /// can work with either backend.
 use std::collections::HashMap;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
@@ -82,6 +82,64 @@ impl NapiRdmCache {
     pub fn collection_count(&self) -> u32 {
         self.inner.len() as u32
     }
+
+    /// Check if a collection is already in the cache.
+    #[napi]
+    pub fn has_collection(&self, collection_id: String) -> bool {
+        self.inner.has_collection(&collection_id)
+    }
+
+    /// Add a collection from a JSON string of concepts.
+    #[napi]
+    pub fn add_collection_from_json(
+        &mut self,
+        collection_id: String,
+        json_str: String,
+    ) -> Result<()> {
+        self.inner
+            .add_collection_from_json(&collection_id, &json_str)
+            .map_err(|e| napi::Error::from_reason(format!("Failed to add collection: {e}")))
+    }
+
+    /// Get the parent concept ID for a concept within a collection.
+    #[napi]
+    pub fn get_parent_id(&self, collection_id: String, concept_id: String) -> Option<String> {
+        self.inner.get_parent_id(&collection_id, &concept_id)
+    }
+
+    /// Remove a collection from the cache.
+    #[napi]
+    pub fn remove_collection(&mut self, collection_id: String) -> bool {
+        self.inner.remove_collection(&collection_id)
+    }
+
+    /// Clear all collections from the cache.
+    #[napi]
+    pub fn clear(&mut self) {
+        self.inner.clear();
+    }
+
+    /// Resolve labels to UUIDs using this cache for lookups.
+    #[napi]
+    pub fn resolve_labels(
+        &self,
+        tree_json: String,
+        alias_to_collection: HashMap<String, String>,
+        strict: bool,
+    ) -> Result<serde_json::Value> {
+        let tree: serde_json::Value = serde_json::from_str(&tree_json)
+            .map_err(|e| napi::Error::from_reason(format!("Invalid tree JSON: {e}")))?;
+
+        let resolved = alizarin_core::label_resolution::resolve_labels(
+            tree,
+            &alias_to_collection,
+            &self.inner,
+            strict,
+        )
+        .map_err(|e| napi::Error::from_reason(e.message))?;
+
+        Ok(resolved)
+    }
 }
 
 // =============================================================================
@@ -118,6 +176,181 @@ impl NapiNodeConfigManager {
     }
 }
 
+// =============================================================================
+// NapiTileData — Map-like interface over HashMap<String, Value>
+// =============================================================================
+
+#[napi]
+pub struct NapiTileData {
+    entries: Arc<Mutex<HashMap<String, serde_json::Value>>>,
+}
+
+#[napi]
+impl NapiTileData {
+    #[napi]
+    pub fn has(&self, key: String) -> bool {
+        self.entries.lock().unwrap().contains_key(&key)
+    }
+
+    #[napi]
+    pub fn get(&self, key: String) -> serde_json::Value {
+        self.entries
+            .lock()
+            .unwrap()
+            .get(&key)
+            .cloned()
+            .unwrap_or(serde_json::Value::Null)
+    }
+
+    #[napi]
+    pub fn set(&mut self, key: String, value: serde_json::Value) {
+        self.entries.lock().unwrap().insert(key, value);
+    }
+
+    #[napi]
+    pub fn delete(&mut self, key: String) -> bool {
+        self.entries.lock().unwrap().remove(&key).is_some()
+    }
+
+    #[napi]
+    pub fn keys(&self) -> Vec<String> {
+        self.entries.lock().unwrap().keys().cloned().collect()
+    }
+}
+
+// =============================================================================
+// NapiStaticTile — Rust-owned tile with Map-like .data access
+// =============================================================================
+
+#[napi]
+pub struct NapiStaticTile {
+    tileid: Option<String>,
+    nodegroup_id: String,
+    sortorder: Option<i32>,
+    resourceinstance_id: String,
+    parenttile_id: Option<String>,
+    provisionaledits: Option<Vec<serde_json::Value>>,
+    data_store: Arc<Mutex<HashMap<String, serde_json::Value>>>,
+}
+
+#[napi]
+impl NapiStaticTile {
+    #[napi(constructor)]
+    pub fn new(
+        nodegroup_id: String,
+        tileid: Option<String>,
+        sortorder: Option<i32>,
+        resourceinstance_id: Option<String>,
+        parenttile_id: Option<String>,
+    ) -> Self {
+        NapiStaticTile {
+            tileid,
+            nodegroup_id,
+            sortorder,
+            resourceinstance_id: resourceinstance_id.unwrap_or_default(),
+            parenttile_id,
+            provisionaledits: None,
+            data_store: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    #[napi(getter)]
+    pub fn data(&self) -> NapiTileData {
+        NapiTileData {
+            entries: self.data_store.clone(),
+        }
+    }
+
+    /// Setter is a no-op — data is always accessed via the NapiTileData getter.
+    /// Exists to prevent TypeError in strict mode when JS does
+    /// `tile.data = tile.data || new Map()`.
+    #[napi(setter)]
+    pub fn set_data(&mut self, _value: serde_json::Value) {
+        // No-op: mutations go through NapiTileData.set/delete
+    }
+
+    #[napi(getter)]
+    pub fn tileid(&self) -> Option<String> {
+        self.tileid.clone()
+    }
+
+    #[napi(setter)]
+    pub fn set_tileid(&mut self, value: Option<String>) {
+        self.tileid = value;
+    }
+
+    #[napi(getter)]
+    pub fn nodegroup_id(&self) -> String {
+        self.nodegroup_id.clone()
+    }
+
+    #[napi(getter)]
+    pub fn sortorder(&self) -> Option<i32> {
+        self.sortorder
+    }
+
+    #[napi(getter)]
+    pub fn resourceinstance_id(&self) -> String {
+        self.resourceinstance_id.clone()
+    }
+
+    #[napi(getter)]
+    pub fn parenttile_id(&self) -> Option<String> {
+        self.parenttile_id.clone()
+    }
+
+    #[napi(setter)]
+    pub fn set_parenttile_id(&mut self, value: Option<String>) {
+        self.parenttile_id = value;
+    }
+
+    #[napi(getter)]
+    pub fn provisionaledits(&self) -> serde_json::Value {
+        match &self.provisionaledits {
+            Some(edits) => serde_json::to_value(edits).unwrap_or(serde_json::Value::Null),
+            None => serde_json::Value::Null,
+        }
+    }
+
+    /// Generate a tile ID if not already set.
+    #[napi(js_name = "ensureId")]
+    pub fn ensure_id(&mut self) -> String {
+        if self.tileid.is_none() {
+            self.tileid = Some(uuid::Uuid::new_v4().to_string());
+        }
+        self.tileid.clone().unwrap()
+    }
+}
+
+impl NapiStaticTile {
+    /// Convert to core StaticTile for storage in PseudoValueCore.
+    pub(crate) fn to_static_tile(&self) -> StaticTile {
+        let data = self.data_store.lock().unwrap().clone();
+        StaticTile {
+            tileid: self.tileid.clone(),
+            nodegroup_id: self.nodegroup_id.clone(),
+            sortorder: self.sortorder,
+            resourceinstance_id: self.resourceinstance_id.clone(),
+            parenttile_id: self.parenttile_id.clone(),
+            provisionaledits: self.provisionaledits.clone(),
+            data,
+        }
+    }
+
+    /// Create from a core StaticTile.
+    pub(crate) fn from_static_tile(tile: &StaticTile) -> Self {
+        NapiStaticTile {
+            tileid: tile.tileid.clone(),
+            nodegroup_id: tile.nodegroup_id.clone(),
+            sortorder: tile.sortorder,
+            resourceinstance_id: tile.resourceinstance_id.clone(),
+            parenttile_id: tile.parenttile_id.clone(),
+            provisionaledits: tile.provisionaledits.clone(),
+            data_store: Arc::new(Mutex::new(tile.data.clone())),
+        }
+    }
+}
+
 // =============================================================================
 // NapiPseudoValue
 // =============================================================================
@@ -269,15 +502,17 @@ impl NapiPseudoValue {
     pub fn to_snapshot(&self) -> serde_json::Value {
         serde_json::json!({
             "nodeId": self.inner.node.nodeid,
+            "name": &self.inner.node.name,
             "alias": self.inner.node.alias,
             "datatype": &self.inner.node.datatype,
             "nodegroupId": self.inner.node.nodegroup_id,
+            "sortorder": self.inner.node.sortorder,
+            "isOuter": self.inner.is_outer(),
+            "isInner": self.inner.is_inner,
             "isCollector": self.inner.is_collector,
+            "accessed": false,
             "independent": self.inner.independent,
-            "exportable": self.inner.node.exportable,
-            "isrequired": self.inner.node.isrequired,
-            "issearchable": self.inner.node.issearchable,
-            "hascustomalias": self.inner.node.hascustomalias,
+            "hasTile": self.inner.tile.is_some(),
             "tileId": self.inner.tile.as_ref().and_then(|t| t.tileid.clone()),
             "tileData": &self.inner.tile_data,
             "valueLoaded": self.inner.tile.is_some(),
@@ -290,6 +525,45 @@ impl NapiPseudoValue {
     pub fn clear(&mut self) {
         self.inner.tile_data = None;
     }
+
+    // -- Tile getter/setter (NapiStaticTile, Rust-owned) --
+
+    #[napi(getter, js_name = "tile")]
+    pub fn get_tile(&self) -> Option<NapiStaticTile> {
+        self.inner
+            .tile
+            .as_ref()
+            .map(|t| NapiStaticTile::from_static_tile(t.as_ref()))
+    }
+
+    #[napi(setter, js_name = "tile")]
+    pub fn set_tile(&mut self, tile: Option<&NapiStaticTile>) {
+        match tile {
+            Some(t) => {
+                self.inner.tile = Some(Arc::new(t.to_static_tile()));
+            }
+            None => {
+                self.inner.tile = None;
+            }
+        }
+    }
+
+    // -- Inner (outer/inner pattern) --
+
+    /// Get the inner PseudoValueCore wrapped as NapiPseudoValue.
+    #[napi(getter)]
+    pub fn inner(&self) -> Option<NapiPseudoValue> {
+        self.inner
+            .inner
+            .as_ref()
+            .map(|i| NapiPseudoValue { inner: *i.clone() })
+    }
+
+    /// Returns null — value is managed JS-side via _cachedValue.
+    #[napi(getter)]
+    pub fn value(&self) -> serde_json::Value {
+        serde_json::Value::Null
+    }
 }
 
 // =============================================================================
@@ -530,19 +804,19 @@ impl NapiResourceInstanceWrapper {
     // Tile loading
     // =========================================================================
 
-    /// Load tiles from a JSON array.
+    /// Load tiles from a JSON string (single-pass deserialization).
     #[napi]
-    pub fn load_tiles(&mut self, tiles_js: serde_json::Value) -> Result<()> {
-        let tiles: Vec<StaticTile> = serde_json::from_value(tiles_js)
+    pub fn load_tiles(&mut self, tiles_json: String) -> Result<()> {
+        let tiles: Vec<StaticTile> = serde_json::from_str(&tiles_json)
             .map_err(|e| napi::Error::from_reason(format!("Invalid tiles JSON: {e}")))?;
         self.inner.load_tiles(tiles);
         Ok(())
     }
 
-    /// Load tiles directly from a StaticResource JSON.
+    /// Load tiles directly from a StaticResource JSON string (single-pass deserialization).
     #[napi]
-    pub fn load_tiles_from_resource(&mut self, resource_js: serde_json::Value) -> Result<()> {
-        let resource: StaticResource = serde_json::from_value(resource_js)
+    pub fn load_tiles_from_resource(&mut self, resource_json: String) -> Result<()> {
+        let resource: StaticResource = serde_json::from_str(&resource_json)
             .map_err(|e| napi::Error::from_reason(format!("Invalid resource JSON: {e}")))?;
 
         self.inner.resource_instance = Some(resource.resourceinstance.clone());
@@ -912,6 +1186,23 @@ impl NapiResourceInstanceWrapper {
     // Path resolution
     // =========================================================================
 
+    /// Resolve a dot-separated path to its target node metadata without needing tiles.
+    ///
+    /// Returns { nodegroupId, isSingle, targetNodeId } — enough for the JS layer to
+    /// lazy-load just that nodegroup's tiles before calling getValuesAtPath.
+    #[napi(js_name = "resolvePath")]
+    pub fn resolve_path(&self, path: String) -> Result<serde_json::Value> {
+        let info = self
+            .inner
+            .resolve_path(&path, &self.model_access)
+            .map_err(|e| napi::Error::from_reason(e.to_string()))?;
+        Ok(serde_json::json!({
+            "nodegroupId": info.nodegroup_id,
+            "isSingle": info.is_single,
+            "targetNodeId": info.target_node.nodeid,
+        }))
+    }
+
     /// Resolve a dot-separated path and return a PseudoList.
     #[napi]
     pub fn get_values_at_path(&self, path: String) -> Result<NapiPseudoList> {

package/src/lib.rs

@@ -529,6 +529,111 @@ pub fn get_registered_extension_handlers() -> Vec<String> {
         .collect()
 }
 
+// ============================================================================
+// SKOS parsing
+// ============================================================================
+
+/// Parse SKOS RDF/XML and return all collections as a JSON array.
+#[napi(js_name = "parseSkosXml")]
+pub fn parse_skos_xml(xml_content: String, base_uri: String) -> Result<serde_json::Value> {
+    let collections = alizarin_core::skos::parse_skos_to_collections(&xml_content, &base_uri)
+        .map_err(napi::Error::from_reason)?;
+    serde_json::to_value(&collections).map_err(|e| napi::Error::from_reason(e.to_string()))
+}
+
+/// Parse SKOS RDF/XML and return a single collection (the first one found).
+#[napi(js_name = "parseSkosXmlToCollection")]
+pub fn parse_skos_xml_to_collection(
+    xml_content: String,
+    base_uri: String,
+) -> Result<serde_json::Value> {
+    let mut collections = alizarin_core::skos::parse_skos_to_collections(&xml_content, &base_uri)
+        .map_err(napi::Error::from_reason)?;
+    if collections.is_empty() {
+        return Err(napi::Error::from_reason(
+            "No SKOS ConceptScheme found in XML".to_string(),
+        ));
+    }
+    let collection = collections.remove(0);
+    serde_json::to_value(&collection).map_err(|e| napi::Error::from_reason(e.to_string()))
+}
+
+// ============================================================================
+// Label resolution utilities
+// ============================================================================
+
+/// Build a mapping from node alias to collection ID based on graph definition.
+///
+/// Equivalent to WASM's `buildAliasToCollectionMap`.
+#[napi(js_name = "buildAliasToCollectionMap")]
+pub fn build_alias_to_collection_map(
+    graph_json: String,
+    resolvable_datatypes: Option<Vec<String>>,
+    config_keys: Option<Vec<String>>,
+) -> Result<HashMap<String, String>> {
+    let graph: serde_json::Value = serde_json::from_str(&graph_json)
+        .map_err(|e| napi::Error::from_reason(format!("Invalid graph JSON: {e}")))?;
+
+    let config = alizarin_core::LabelResolutionConfig {
+        resolvable_datatypes: resolvable_datatypes.unwrap_or_else(|| {
+            alizarin_core::DEFAULT_RESOLVABLE_DATATYPES
+                .iter()
+                .map(|s| s.to_string())
+                .collect()
+        }),
+        config_keys: config_keys.unwrap_or_else(|| {
+            alizarin_core::DEFAULT_CONFIG_KEYS
+                .iter()
+                .map(|s| s.to_string())
+                .collect()
+        }),
+        strict: false,
+    };
+
+    Ok(alizarin_core::build_alias_to_collection_map(
+        &graph, &config,
+    ))
+}
+
+/// Scan a JSON tree to find which collections are needed for resolution.
+///
+/// Equivalent to WASM's `findNeededCollections`.
+#[napi(js_name = "findNeededCollections")]
+pub fn find_needed_collections(
+    tree_json: String,
+    alias_to_collection: HashMap<String, String>,
+) -> Result<Vec<String>> {
+    let tree: serde_json::Value = serde_json::from_str(&tree_json)
+        .map_err(|e| napi::Error::from_reason(format!("Invalid tree JSON: {e}")))?;
+
+    let needed = alizarin_core::find_needed_collections(&tree, &alias_to_collection);
+    Ok(needed.into_iter().collect())
+}
+
+/// Check if a string is a valid UUID.
+#[napi(js_name = "isValidUuid")]
+pub fn is_valid_uuid(s: String) -> bool {
+    alizarin_core::is_valid_uuid(&s)
+}
+
+/// Get the default resolvable datatypes (concept, concept-list).
+#[napi(js_name = "getDefaultResolvableDatatypes")]
+pub fn get_default_resolvable_datatypes() -> Vec<String> {
+    alizarin_core::DEFAULT_RESOLVABLE_DATATYPES
+        .iter()
+        .map(|s| s.to_string())
+        .collect()
+}
+
+/// Get the default config keys for collection IDs.
+#[napi(js_name = "getDefaultConfigKeys")]
+pub fn get_default_config_keys() -> Vec<String> {
+    alizarin_core::DEFAULT_CONFIG_KEYS
+        .iter()
+        .map(|s| s.to_string())
+        .collect()
+}
+
 // ============================================================================
 // Prebuild import (high-level convenience)
 // ============================================================================