Arrows and Contexts

insert_arrow!(stname, alias, name, pm) -> ArrowPtr

Register a new arrow type in the directory. Returns the allocated ArrowPtr.

• stname: ST type name ("NEAR", "LEADSTO", "CONTAINS", "EXPRESS")
• alias: Short name/alias for the arrow
• name: Long descriptive name
• pm: Sign string ("+" or "-")

insert_inverse_arrow!(fwd::ArrowPtr, bwd::ArrowPtr)

Register a pair of arrows as inverses of each other.

get_arrow_by_name(name::AbstractString) -> Union{ArrowEntry, Nothing}

Look up an arrow by its short or long name.

get_arrow_by_ptr(ptr::ArrowPtr) -> ArrowEntry

Look up an arrow by its pointer. Throws if not found.

get_stindex_by_name(stname::AbstractString, pm::AbstractString) -> Int

Convert a Semantic Spacetime type name and sign into a 1-based array index. stname is one of "NEAR", "LEADSTO", "CONTAINS", "EXPRESS" (case-insensitive). pm is "+" or "-" (or "" for NEAR).

get_sttype_from_arrows(arrows::Vector{ArrowPtr}) -> Vector{Int}

Extract the set of unique ST type indices from a list of arrow pointers.

print_stindex(stindex::Int) -> String

Return a human-readable label for an ST array index.

add_mandatory_arrows!()

Register the mandatory built-in arrow types required by the SST system. This includes sequence arrows (then/from), extract arrows, fragment arrows, intent/ambient property arrows, and URL/image arrows. Called automatically by parse_n4l.

ClosureRule

A rule for composing two consecutive arrows into a result arrow.

load_arrow_closures(config_dir::AbstractString) -> Vector{ClosureRule}

Read closure rules from closures.sst in the config directory. Format: arrow1 + arrow2 => result_arrow (one per line). Lines starting with # are comments.

apply_arrow_closures!(store::AbstractSSTStore, rules::Vector{ClosureRule})

For each node, check pairs of consecutive outgoing links where a closure rule applies, and add the composed link.

complete_inferences!(store::AbstractSSTStore)

Apply inference completions to all nodes: closeness (NEAR symmetry), sequence completion, and ETC type validation.

complete_closeness!(store::AbstractSSTStore, node::Node)

Apply symmetric closure for NEAR links: if A is near B and A is near C by the same arrow type, then B and C should also be near each other.

complete_sequences!(store::AbstractSSTStore, node::Node)

Complete sequence chains: if A→B and B→C are in sequence, verify the chain is consistent. (Placeholder for full transitive closure.)

register_context!(context::Vector{String}) -> ContextPtr

Register a context (given as a vector of labels) in the directory. Returns the pointer to the existing or newly created entry.

try_context(context::Vector{String}) -> ContextPtr

Look up or register a context. Returns 0 for empty contexts.

get_context(ptr::ContextPtr) -> String

Retrieve the context string for a given pointer. Returns "" for pointer 0 or out-of-range pointers.

compile_context_string(context::Vector{String}) -> String

Combine a vector of context labels into a single canonical comma-separated string (sorted, deduplicated, stripped).

normalize_context_string(ctx::Vector{String}) -> String

Normalize a context vector: sort, deduplicate, join with commas. Alias for compile_context_string matching the Go API.

new_node_directory() -> NodeDirectory

Create an empty node directory.

append_text_to_directory!(nd::NodeDirectory, event::Node) -> NodePtr

Add a node to the directory. Returns the NodePtr for the (possibly existing) node. Idempotent — returns existing pointer if text already registered.

append_text_to_directory!(event::Node) -> NodePtr

Append to the global node directory.

check_existing_or_alt_caps(nd::NodeDirectory, event::Node) -> (ClassedNodePtr, Bool)

Check if a node with the same text (or different capitalization) already exists. Returns (pointer, found). Logs a warning if an alternative capitalization exists.

check_existing_or_alt_caps(event::Node) -> (ClassedNodePtr, Bool)

Check using the global node directory.

get_node_txt_from_ptr(nd::NodeDirectory, ptr::NodePtr) -> String

Get the text of a node by its pointer. Returns "" if not found.

get_memory_node_from_ptr(nd::NodeDirectory, ptr::NodePtr) -> Node

Retrieve a node from memory by its pointer. Returns empty node if not found.

get_appointed_nodes_by_arrow(store::MemoryStore, arrow::Int;
                             context::Vector{String}=String[],
                             chapter::AbstractString="any",
                             size::Int=100) -> Dict{Int, Vector{Appointment}}

Get appointed nodes grouped by arrow type (memory-backed). Finds nodes that have incoming links with the specified arrow, groups them by arrow pointer, and filters by chapter and context.

get_appointed_nodes_by_arrow(sst::SSTConnection, arrow::Int;
                             context::Vector{String}=String[],
                             chapter::AbstractString="any",
                             size::Int=100) -> Dict{Int, Vector{Appointment}}

Get appointed nodes grouped by arrow type using the PostgreSQL stored procedure.

get_appointed_nodes_by_sttype(store::MemoryStore, sttype::Int;
                              context::Vector{String}=String[],
                              chapter::AbstractString="any",
                              size::Int=100) -> Dict{Int, Vector{Appointment}}

Get appointed nodes grouped by STType (memory-backed). Scans nodes for incoming links in the specified ST channel, groups results by arrow pointer.

get_appointed_nodes_by_sttype(sst::SSTConnection, sttype::Int;
                              context::Vector{String}=String[],
                              chapter::AbstractString="any",
                              size::Int=100) -> Dict{Int, Vector{Appointment}}

Get appointed nodes grouped by STType using the PostgreSQL stored procedure.

parse_appointed_node_cluster(whole::AbstractString) -> Appointment

Parse a PostgreSQL appointment cluster tuple string into an Appointment. Expected format: (arr,sttype,chapter,"{ctx1,ctx2}","(class,cptr)","{"(c,p)",...}")