alizarin 0.2.1-alpha.83

package/dist/main.d.ts

@@ -0,0 +1,28 @@
+import * as client from "./client";
+import * as interfaces from "./interfaces";
+import { RDM, ResolveLabelsOptions, registerResolvableDatatype, unregisterResolvableDatatype } from "./rdm";
+import { ResourceModelWrapper, createWKRM, getWKRMClass, graphManager, staticStore, GraphManager, GraphMutator } from "./graphManager";
+import * as staticTypes from "./static-types";
+import { CollectionMutator } from "./collectionMutator";
+import { buildGraphFromModelCsvs, validateModelCsvs, buildResourcesFromBusinessCsv } from "./csvModelLoader";
+import type { CsvModelDiagnostic, CsvModelBuildResult, BusinessDataResult } from "./csvModelLoader";
+import * as utils from "./utils";
+import * as viewModels from "./viewModels";
+import * as renderers from "./renderers";
+import * as nodeConfig from "./nodeConfig";
+import { setWasmURL, ensureWasmRdmCache, parseSkosXml, parseSkosXmlToCollection, collectionToSkosXml, collectionsToSkosXml, registerExtensionHandler } from "./_wasm";
+import { setBackend, setNapiModule, getBackend, autoDetectBackend, createResourceRegistry } from "./backend";
+import type { BackendType } from "./backend";
+import { resetTimingStats, getTimingStats, logTimingStats } from "./semantic";
+import * as tracing from "./tracing";
+import { IStringKeyedObject } from "./interfaces";
+export declare const version: string;
+declare const wasmReady: Promise<void>;
+declare const _wrappedInitWasm: () => Promise<void>;
+declare const AlizarinModel: typeof viewModels.ResourceInstanceViewModel;
+declare const setCurrentLanguage: typeof utils.setCurrentLanguage;
+declare const getCurrentLanguage: typeof utils.getCurrentLanguage;
+declare const slugify: typeof utils.slugify;
+export type { IStringKeyedObject, ResolveLabelsOptions, CsvModelDiagnostic, CsvModelBuildResult, BusinessDataResult, };
+export { AlizarinModel, client, graphManager, GraphManager, staticTypes, utils, slugify, viewModels, staticStore, RDM, registerResolvableDatatype, unregisterResolvableDatatype, renderers, interfaces, createWKRM, getWKRMClass, nodeConfig, ResourceModelWrapper, GraphMutator, setCurrentLanguage, getCurrentLanguage, _wrappedInitWasm as initWasm, setWasmURL, wasmReady, ensureWasmRdmCache, resetTimingStats, getTimingStats, logTimingStats, tracing, parseSkosXml, parseSkosXmlToCollection, collectionToSkosXml, collectionsToSkosXml, CollectionMutator, buildGraphFromModelCsvs, validateModelCsvs, buildResourcesFromBusinessCsv, registerExtensionHandler, setBackend, setNapiModule, getBackend, autoDetectBackend, createResourceRegistry, };
+export type { BackendType };

package/dist/nodeConfig.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Node configuration management.
+ *
+ * TypeScript wrappers around the Rust/WASM NodeConfigManager.
+ * Config parsing and storage is done in Rust, shared with Python bindings.
+ */
+import { INodeConfig } from './interfaces';
+import { StaticNode, StaticDomainValue, StaticGraph } from './static-types';
+import { WasmNodeConfigBoolean, WasmNodeConfigConcept, WasmNodeConfigDomain, WasmNodeConfigReference } from '../pkg/alizarin';
+declare class StaticNodeConfigBoolean implements INodeConfig {
+    private _wasm;
+    constructor(wasmConfig: WasmNodeConfigBoolean);
+    get i18n_properties(): string[];
+    get falseLabel(): {
+        [key: string]: string;
+    };
+    get trueLabel(): {
+        [key: string]: string;
+    };
+    getLabel(value: boolean, language: string): string | undefined;
+}
+declare class StaticNodeConfigConcept implements INodeConfig {
+    private _wasm;
+    constructor(wasmConfig: WasmNodeConfigConcept);
+    get rdmCollection(): string;
+}
+declare class StaticNodeConfigReference implements INodeConfig {
+    private _wasm;
+    constructor(wasmConfig: WasmNodeConfigReference);
+    get controlledList(): string;
+    get rdmCollection(): string;
+    get multiValue(): boolean;
+    getCollectionId(): string | undefined;
+}
+declare class StaticNodeConfigDomain implements INodeConfig {
+    private _wasm;
+    private _optionsCache;
+    constructor(wasmConfig: WasmNodeConfigDomain);
+    get i18n_config(): {
+        [key: string]: string;
+    };
+    get options(): StaticDomainValue[];
+    getSelected(): StaticDomainValue | undefined;
+    valueFromId(id: string): StaticDomainValue | undefined;
+}
+type NodeConfigType = StaticNodeConfigBoolean | StaticNodeConfigConcept | StaticNodeConfigDomain | StaticNodeConfigReference;
+declare class NodeConfigManager {
+    private _backendManager;
+    private _cache;
+    private _graphsLoaded;
+    private getBackendManager;
+    /** The backend-native manager (WASM or NAPI). Used by forDisplayJson. */
+    get wasmManager(): any;
+    loadFromGraph(graph: StaticGraph): void;
+    retrieve(node: StaticNode): NodeConfigType | null;
+    private getConfigFromWasm;
+    clear(): void;
+    hasGraph(graphId: string): boolean;
+}
+declare const nodeConfigManager: NodeConfigManager;
+export { nodeConfigManager, StaticNodeConfigDomain, StaticNodeConfigBoolean, StaticNodeConfigConcept, StaticNodeConfigReference, NodeConfigManager, };

package/dist/pseudos.d.ts

@@ -0,0 +1,118 @@
+import { StaticTile, StaticNode } from "./static-types";
+import { IViewModel, IPseudo, IRIVM } from "./interfaces";
+import { AttrPromise } from "./utils";
+import { PseudoNode, WasmPseudoValue, WasmPseudoList } from '../pkg/alizarin';
+declare class PseudoUnavailable implements IPseudo {
+    parentValue: PseudoValue<any> | null;
+    tile: null;
+    node: StaticNode;
+    isOuter: boolean;
+    constructor(node: StaticNode);
+    forJson(): Promise<{
+        [key: string]: any;
+    }[] | null>;
+    describeField(): string;
+    describeFieldGroup(): string;
+    getValue(): AttrPromise<null>;
+    getLength(): number;
+    getChildren(_?: boolean): any[];
+    isIterable(): boolean;
+}
+/**
+ * PseudoValue - Thin JS wrapper around WasmPseudoValue from Rust
+ *
+ * Most state and logic now lives in Rust's RustPseudoValue/WasmPseudoValue.
+ * This wrapper provides:
+ * 1. JS-specific getViewModel integration
+ * 2. Promise-based value loading with AttrPromise
+ * 3. Inner/outer pattern coordination
+ */
+declare class PseudoValue<VM extends IViewModel> implements IPseudo {
+    private _wasm;
+    parent: IRIVM<any> | null;
+    _parentValue: PseudoValue<any> | null;
+    private _inner;
+    private _cachedValue;
+    private _snapshot;
+    private getSnapshot;
+    get datatype(): string;
+    get isInner(): boolean;
+    get isOuter(): boolean;
+    get tile(): StaticTile | null;
+    set tile(t: StaticTile | null);
+    get value(): any;
+    get valueLoaded(): boolean | undefined;
+    get accessed(): boolean;
+    get independent(): boolean;
+    get originalTile(): StaticTile | null;
+    get node(): WasmPseudoValue;
+    get nodeid(): string;
+    get inner(): PseudoValue<any> | null;
+    get parentValue(): PseudoValue<any> | null;
+    set parentValue(newParentValue: PseudoValue<any> | null);
+    isIterable(): boolean;
+    describeField(): string;
+    describeFieldGroup(): string;
+    /**
+     * Create PseudoValue from WasmPseudoValue (preferred constructor)
+     */
+    static fromWasm<VM extends IViewModel>(wasm: WasmPseudoValue, parent: IRIVM<any>): PseudoValue<VM>;
+    /**
+     * Private constructor - use static factories
+     */
+    private constructor();
+    static create<VM extends IViewModel>(nodeOrAlias: StaticNode | string, tile: StaticTile | null, value: any, parent: IRIVM<any>): PseudoValue<VM>;
+    getParentTileId(): string | null;
+    getTile(): Promise<[StaticTile | null, any[]]>;
+    clear(): void;
+    updateValue(newTile?: StaticTile | null): AttrPromise<VM>;
+    private _updateValueReal;
+    /**
+     * Sync the ViewModel's tile data to Rust.
+     * Called after VM creation/resolution so toTiles()/toResource() can serialize.
+     */
+    private syncTileData;
+    getValue(): AttrPromise<VM | null>;
+    getLength(): number;
+    getChildTypes(): Promise<object>;
+    getChildren(direct?: boolean | null): IPseudo[];
+    forJson(): Promise<{
+        [key: string]: any;
+    } | {
+        [key: string]: any;
+    }[] | string | number | boolean | null>;
+}
+declare class PseudoList extends Array implements IPseudo {
+    node: StaticNode | undefined;
+    parent: IRIVM<any> | null | undefined;
+    parentValue: PseudoValue<any> | null;
+    tile: StaticTile | undefined;
+    parenttileId: string | undefined;
+    ghostChildren: Set<PseudoValue<any>> | null;
+    isOuter: boolean;
+    /** Whether this list represents a cardinality-1 node (should unwrap to single value in forJson) */
+    isSingle: boolean;
+    isIterable(): boolean;
+    sorted(): Promise<any[]>;
+    describeField(): string;
+    describeFieldGroup(): string;
+    initialize(node: StaticNode, parent: IRIVM<any> | null): void;
+    forJson(): Promise<{
+        [key: string]: any;
+    }[] | {
+        [key: string]: any;
+    } | null>;
+    getValue(): AttrPromise<PseudoList | IViewModel | null>;
+    toString(): string;
+}
+/**
+ * Thin wrapper to convert Rust WasmPseudoValue/WasmPseudoList to TS PseudoValue/PseudoList
+ * This is the ONLY place where Rust values should be wrapped in TS classes
+ *
+ * @param rustValue - WasmPseudoValue or WasmPseudoList from Rust
+ * @param wkri - The WKRI wrapper (parent IRIVM)
+ * @param model - The model wrapper (for getting nodes - currently unused with new pattern)
+ * @returns PseudoValue, PseudoList, or PseudoUnavailable
+ */
+declare function wrapRustPseudo(rustValue: WasmPseudoValue | WasmPseudoList | null, wkri: IRIVM<any>, model: any): PseudoValue<any> | PseudoList | PseudoUnavailable | null | undefined;
+export { PseudoNode, PseudoValue, PseudoList, PseudoUnavailable, wrapRustPseudo };

package/dist/rdm.d.ts

@@ -0,0 +1,68 @@
+import { StaticCollection, StaticGraph } from "./static-types";
+import { ArchesClient } from "./client";
+import { isValidUuid } from "../pkg/alizarin";
+export { isValidUuid };
+/**
+ * Register an additional datatype for label resolution.
+ * Extensions should call this to include their datatypes in resolveLabels.
+ * E.g. CLM registers "reference" so reference labels are resolved.
+ */
+declare function registerResolvableDatatype(datatype: string): void;
+/**
+ * Unregister a previously registered resolvable datatype.
+ */
+declare function unregisterResolvableDatatype(datatype: string): void;
+interface ResolveLabelsOptions {
+    /** If true, throw errors for unresolved labels. Default: false */
+    strict?: boolean;
+    /** Additional datatypes to resolve beyond the defaults and any extension-registered types */
+    additionalDatatypes?: string[];
+    /** Additional config keys to check for collection IDs */
+    additionalConfigKeys?: string[];
+}
+declare class ReferenceDataManager {
+    archesClient: ArchesClient;
+    collections: Map<string, Promise<StaticCollection>>;
+    constructor(archesClient: ArchesClient);
+    retrieveCollection(id: string): Promise<StaticCollection>;
+    /**
+     * Add a pre-loaded collection to the cache.
+     */
+    addCollection(collection: StaticCollection): void;
+    /**
+     * Check if a collection is cached.
+     */
+    hasCollection(id: string): boolean;
+    /**
+     * Clear a specific collection from cache.
+     * Also clears from the Rust RDM cache if available.
+     */
+    clearCollection(id: string): void;
+    /**
+     * Clear all cached collections.
+     * Also clears the Rust RDM cache if available.
+     */
+    clear(): void;
+    /**
+     * Resolve label strings to UUIDs in a JSON tree.
+     *
+     * Uses centralized Rust/WASM implementation for tree traversal and resolution.
+     * Only loads collections that are actually needed (lazy loading).
+     *
+     * @param tree - The data tree to resolve
+     * @param graph - The graph definition (for node configs)
+     * @param options - Resolution options
+     * @returns The tree with labels resolved to UUIDs
+     *
+     * @example
+     * ```typescript
+     * const tree = { status: ["Active", "Pending"] };
+     * const resolved = await RDM.resolveLabels(tree, graph);
+     * // resolved = { status: ["uuid-1", "uuid-2"] }
+     * ```
+     */
+    resolveLabels<T extends object>(tree: T, graph: StaticGraph, options?: ResolveLabelsOptions): Promise<T>;
+}
+declare const RDM: ReferenceDataManager;
+export { StaticCollection, ReferenceDataManager, RDM, registerResolvableDatatype, unregisterResolvableDatatype };
+export type { ResolveLabelsOptions };

package/dist/renderers.d.ts

@@ -0,0 +1,65 @@
+import { UrlViewModel, DateViewModel, ResourceInstanceViewModel, DomainValueViewModel, ConceptValueViewModel, NonLocalizedStringViewModel, StringViewModel, SemanticViewModel, BooleanViewModel, NumberViewModel } from './viewModels';
+declare class Cleanable extends String {
+    __clean: string | undefined;
+}
+declare abstract class BaseRenderer {
+    render(asset: ResourceInstanceViewModel<any>): Promise<any>;
+    abstract renderDomainValue(value: DomainValueViewModel, _depth: number): Promise<any>;
+    abstract renderDate(value: DateViewModel, _depth: number): Promise<any>;
+    abstract renderConceptValue(value: ConceptValueViewModel, _depth: number): Promise<any>;
+    abstract renderResourceReference(value: ResourceInstanceViewModel<any>, _depth: number): Promise<any>;
+    abstract renderSemantic(value: SemanticViewModel, depth: number): Promise<any>;
+    abstract renderBlock(block: {
+        [key: string]: string;
+    } | {
+        [key: string]: string;
+    }[], depth: number): any;
+    abstract renderArray(value: any[], depth: number): Promise<any>;
+    abstract renderString(value: string | StringViewModel | NonLocalizedStringViewModel, _depth: number): Promise<any>;
+    abstract renderBoolean(value: boolean | BooleanViewModel, _depth: number): Promise<any>;
+    abstract renderNumber(value: number | NumberViewModel, _depth: number): Promise<any>;
+    abstract renderUrl(value: UrlViewModel, _depth: number): Promise<any>;
+    renderValue(value: any, depth: number): Promise<any>;
+}
+declare class Renderer extends BaseRenderer {
+    renderDomainValue(value: DomainValueViewModel, _depth: number): Promise<any>;
+    renderString(value: string | StringViewModel | NonLocalizedStringViewModel, _depth: number): Promise<any>;
+    renderNumber(value: number | NumberViewModel, _depth: number): Promise<any>;
+    renderBoolean(value: boolean | BooleanViewModel, _depth: number): Promise<any>;
+    renderDate(value: DateViewModel, _depth: number): Promise<any>;
+    renderConceptValue(value: ConceptValueViewModel, _depth: number): Promise<any>;
+    renderResourceReference(value: ResourceInstanceViewModel<any>, _depth: number): Promise<any>;
+    renderSemantic(value: SemanticViewModel, depth: number): Promise<any>;
+    renderUrl(value: UrlViewModel, _depth: number): Promise<any>;
+    renderBlock(block: {
+        [key: string]: string;
+    } | {
+        [key: string]: string;
+    }[], depth: number): any;
+    renderArray(value: any, depth: number): Promise<any>;
+}
+declare class MarkdownRenderer extends Renderer {
+    conceptValueToUrl: ((value: ConceptValueViewModel) => string) | undefined;
+    dateToText: ((value: DateViewModel) => string) | undefined;
+    domainValueToUrl: ((value: DomainValueViewModel) => string) | undefined;
+    resourceReferenceToUrl: ((value: ResourceInstanceViewModel<any>) => string) | undefined;
+    nodeToUrl: ((value: string) => string) | undefined;
+    constructor(callbacks: {
+        conceptValueToUrl: ((value: ConceptValueViewModel) => string) | undefined;
+        dateToText: ((value: DateViewModel) => string) | undefined;
+        domainValueToUrl: ((value: DomainValueViewModel) => string) | undefined;
+        resourceReferenceToUrl: ((value: ResourceInstanceViewModel<any>) => string) | undefined;
+        nodeToUrl: ((value: string) => string) | undefined;
+    });
+    renderUrl(value: UrlViewModel, _depth: number): Promise<any>;
+    renderDomainValue(domainValue: DomainValueViewModel, _: number): Promise<any>;
+    renderDate(date: DateViewModel, _: number): Promise<any>;
+    renderConceptValue(conceptValue: ConceptValueViewModel, _: number): Promise<any>;
+    renderResourceReference(rivm: ResourceInstanceViewModel<any>, _: number): Promise<any>;
+}
+declare class FlatMarkdownRenderer extends MarkdownRenderer {
+    renderSemantic(vm: SemanticViewModel, depth: number): Promise<any>;
+    renderArray(value: any, depth: number): Promise<any>;
+    renderString(value: string | StringViewModel | NonLocalizedStringViewModel, _depth: number): Promise<any>;
+}
+export { MarkdownRenderer, Cleanable, FlatMarkdownRenderer };

package/dist/semantic.d.ts

@@ -0,0 +1,35 @@
+import { IStringKeyedObject, IViewModel, IPseudo, IRIVM } from "./interfaces.ts";
+import type { PseudoValue } from "./pseudos";
+import { StaticTile, StaticNode } from "./static-types";
+export declare function resetTimingStats(): void;
+export declare function getTimingStats(): {
+    wasmAvgMs: number;
+    wrapAvgMs: number;
+    wasmCalls: number;
+    wasmTotalMs: number;
+    wrapCalls: number;
+    wrapTotalMs: number;
+};
+export declare function logTimingStats(label?: string): void;
+declare class SemanticViewModel implements IStringKeyedObject, IViewModel {
+    [key: string | symbol]: any;
+    _: IViewModel | Promise<IViewModel> | undefined;
+    then: undefined;
+    [Symbol.toPrimitive]: undefined;
+    get [Symbol.toStringTag](): string;
+    __parentPseudo: PseudoValue<any> | undefined;
+    __childValues: Map<string, any>;
+    __parentWkri: IRIVM<any> | null;
+    __tile: StaticTile | null;
+    __node: StaticNode;
+    __forJsonCache(): null;
+    constructor(parentWkri: IRIVM<any> | null, tile: StaticTile | null, node: StaticNode);
+    toString(): Promise<string>;
+    toObject(): Promise<Record<string, any>>;
+    __get(key: string): Promise<IViewModel | IViewModel[]>;
+    __has(key: string): any;
+    __getChildValue(key: string): Promise<IPseudo> | null | undefined;
+    static __create(tile: StaticTile, node: StaticNode, _value: any, parent: IRIVM<any> | null): Promise<SemanticViewModel>;
+    __asTileData(): Promise<[null, any[]]>;
+}
+export { SemanticViewModel };

package/dist/static-types.d.ts

@@ -0,0 +1,172 @@
+import { StaticGraphMeta, StaticNode, StaticTranslatableString, StaticNodegroup, StaticConstraint, StaticCard, StaticCardsXNodesXWidgets, StaticFunctionsXGraphs, StaticPublication, StaticTile, StaticGraph, StaticEdge, StaticResourceDescriptors, StaticResourceMetadata, StaticResourceSummary, StaticResourceReference, StaticResource, StaticResourceRegistry } from '../pkg/alizarin';
+interface IStaticDescriptorConfig {
+    descriptor_types: {
+        nodegroup_id: string;
+        string_template: string;
+    }[];
+}
+declare function createStaticGraph(props: {
+    author?: string;
+    color?: string | null;
+    config?: object;
+    deploymentdate?: null | string;
+    deploymentfile?: null | string;
+    description?: string | StaticTranslatableString;
+    graphid?: string;
+    iconclass?: string;
+    is_editable?: boolean | null;
+    isresource?: boolean;
+    jsonldcontext?: string | {
+        [key: string]: any;
+    } | null;
+    name: string | StaticTranslatableString;
+    ontology_id?: string | string[] | null;
+    relatable_resource_model_ids?: Array<string>;
+    resource_2_resource_constraints?: Array<any> | null;
+    slug?: string | null;
+    subtitle?: string | StaticTranslatableString;
+    template_id?: string;
+    version?: string;
+}, published?: boolean): StaticGraph;
+declare class StaticValue {
+    id: string;
+    value: string;
+    __concept?: StaticConcept | null;
+    __conceptId?: string | null;
+    constructor(jsonData: StaticValue, concept?: StaticConcept | string | null);
+    toJSON(): {
+        id: string;
+        value: string;
+    };
+    toString(): string;
+    static create(referent: string | StaticConcept, valueType: string, value: string, language?: string): StaticValue;
+}
+declare class StaticConcept {
+    id: string;
+    prefLabels: {
+        [lang: string]: StaticValue;
+    };
+    source: string | null;
+    sortOrder: number | null;
+    children: StaticConcept[] | null;
+    constructor(jsonData: StaticConcept);
+    getPrefLabel?(): StaticValue;
+    toString(): any;
+    static fromValue(conceptScheme: StaticConcept | null, value: string | StaticValue | {
+        [lang: string]: StaticValue;
+    }, children?: (string | StaticValue | StaticConcept)[], config?: {
+        baseLanguage?: string;
+        source?: string | null;
+        sortOrder?: number | null;
+    }): StaticConcept;
+}
+/**
+ * Type of SKOS grouping structure.
+ * - ConceptScheme: Uses narrower/broader hierarchy (default)
+ * - Collection: Uses flat member relationships (Arches-compatible)
+ */
+export type SkosNodeType = 'ConceptScheme' | 'Collection';
+declare class StaticCollection {
+    id: string;
+    uri?: string;
+    prefLabels: {
+        [lang: string]: StaticValue;
+    };
+    altLabels?: {
+        [lang: string]: StaticValue[];
+    };
+    scopeNotes?: {
+        [lang: string]: StaticValue;
+    };
+    nodeType: SkosNodeType;
+    concepts: {
+        [conceptId: string]: StaticConcept;
+    };
+    __allConcepts: {
+        [conceptId: string]: StaticConcept;
+    };
+    __values: {
+        [valueId: string]: StaticValue;
+    };
+    static fromConceptScheme(props: {
+        collectionid?: string;
+        name?: string | {
+            [lang: string]: StaticValue;
+        } | StaticValue;
+        conceptScheme: StaticConcept;
+        nodeType?: SkosNodeType;
+    }): StaticCollection;
+    /**
+     * Create a new StaticCollection.
+     * @param props.nodeType - 'ConceptScheme' (default) for hierarchical, 'Collection' for flat Arches-compatible
+     */
+    static create(props: {
+        collectionid?: string;
+        uri?: string;
+        name: string | {
+            [lang: string]: StaticValue;
+        } | StaticValue;
+        concepts: StaticConcept[] | {
+            [conceptId: string]: StaticConcept;
+        };
+        nodeType?: SkosNodeType;
+    }): StaticCollection;
+    constructor(jsonData: StaticCollection);
+    getConceptValue?(valueId: string): StaticValue;
+    getConceptByValue?(label: string): StaticConcept;
+    private _syncedToRustCache;
+    /**
+     * Ensure this collection is synced to the Rust RDM cache.
+     * This is called automatically by hierarchy methods, but can be called
+     * explicitly to pre-sync collections before label resolution.
+     * @throws Error if WASM is not initialized
+     */
+    ensureInCache?(): void;
+    /**
+     * Get the parent concept ID for a given concept.
+     * Uses the Rust RDM cache for hierarchy lookups.
+     * @returns The parent concept ID, or null if no parent (top-level concept)
+     * @throws Error if WASM is not initialized
+     */
+    getParentId?(conceptId: string): string | null;
+    /**
+     * Get the parent concept for a given concept.
+     * @returns The parent concept, or null if no parent
+     */
+    getParent?(conceptId: string): StaticConcept | null;
+    /**
+     * Get all ancestor concepts for a given concept (parent, grandparent, etc).
+     * Returns in order from immediate parent to root.
+     */
+    getAncestors?(conceptId: string): StaticConcept[];
+    /**
+     * Ensure this collection's data is in the Rust RDM cache.
+     * Called lazily when hierarchy lookups are needed.
+     * @internal
+     */
+    private _ensureInRustCache;
+    /**
+     * Convert collection concepts to the format expected by Rust cache.
+     * @internal
+     */
+    private _toRustCacheFormat;
+    toString(): string;
+}
+declare class StaticDomainValue {
+    id: string;
+    selected: boolean;
+    text: {
+        [lang: string]: string;
+    };
+    constructor(jsonData: StaticDomainValue);
+    toString(): string;
+    lang(lang: string): string | undefined;
+    forJson(): Promise<{
+        id: string;
+        selected: boolean;
+        text: {
+            [lang: string]: string;
+        };
+    }>;
+}
+export { StaticValue, StaticTile, StaticGraph, createStaticGraph, StaticResource, StaticResourceSummary, StaticResourceMetadata, StaticResourceRegistry, StaticNode, StaticNodegroup, StaticEdge, StaticCard, StaticCardsXNodesXWidgets, StaticCollection, StaticConcept, StaticDomainValue, StaticResourceReference, StaticGraphMeta, StaticFunctionsXGraphs, StaticResourceDescriptors, StaticTranslatableString, StaticConstraint, StaticPublication, type IStaticDescriptorConfig, type SkosNodeType };

package/dist/staticStore.d.ts

@@ -0,0 +1,60 @@
+import { ArchesClient } from "./client.ts";
+import { StaticResource, StaticResourceSummary, StaticResourceMetadata, StaticResourceRegistry, StaticTile } from "./static-types";
+/**
+ * StaticStore - Thin wrapper around StaticResourceRegistry with optional archesClient fallback
+ *
+ * Primary mode: Resources are pre-loaded into the registry before use.
+ * Fallback mode: If archesClient is set and resource not in registry, loads on-demand.
+ *
+ * Methods return sync results wrapped in Promises for API compatibility.
+ */
+declare class StaticStore {
+    private _registry;
+    private _archesClient;
+    constructor(registry?: StaticResourceRegistry);
+    get archesClient(): ArchesClient | null;
+    set archesClient(client: ArchesClient | null);
+    /**
+     * Get or create the registry (lazy initialization for WASM timing)
+     */
+    get registry(): StaticResourceRegistry;
+    /**
+     * Set the registry (allows replacing with a pre-populated registry)
+     */
+    set registry(registry: StaticResourceRegistry);
+    /**
+     * Get metadata for a resource from the registry (or load via archesClient if available).
+     */
+    getMeta(id: string, onlyIfCached?: boolean): Promise<StaticResourceMetadata | null>;
+    /**
+     * Get all full resources for a graph.
+     * First yields from registry, then loads remaining via archesClient if available.
+     */
+    loadAll(graphId: string, limit?: number | undefined, useCache?: boolean): AsyncIterable<StaticResource>;
+    /**
+     * Get a full resource from the registry (or load via archesClient if available).
+     */
+    loadOne(id: string): Promise<StaticResource>;
+    /**
+     * Get all summaries for a graph.
+     */
+    loadAllSummaries(graphId: string, limit?: number | undefined): AsyncIterable<StaticResourceSummary>;
+    /**
+     * Get tiles for a resource.
+     */
+    loadTiles(id: string, nodegroupId?: string | null): Promise<StaticTile[]>;
+    /**
+     * Get a full resource with tiles loaded.
+     */
+    ensureFullResource(id: string): Promise<StaticResource>;
+    /**
+     * Check if a resource exists in the registry.
+     */
+    contains(id: string): boolean;
+    /**
+     * Check if a full resource (with tiles) exists in the registry.
+     */
+    hasFull(id: string): boolean;
+}
+declare const staticStore: StaticStore;
+export { staticStore, StaticStore };