Conventional systems in the stack — built and adopted, layer by layer

Crosswalker is a stack of layered conventions — formalized systems (little languages, schemas, and vocabularies), some we built, some we adopted from existing standards and combined into a coherent whole. This page is the map: the entire pipeline at a glance, with each layer linking down to the page that goes deep. Start here; follow any layer that interests you.

How to read this page

This is a high-level map of content — a hub, not a deep-dive. Don’t recognize a term? Every chip in the diagram is a link — click it to jump straight to its definition. For the component + data-flow detail see system architecture. For the front half — how external data becomes a vault — see Mapping into Obsidian. For the output language see data morphology.

Artifact-role guardrails

Use the distinctions in artifact roles and authority: transforms are bounded changes; projections name their target; translation means a narrow interlingua/adapter step; compilation requires an explicit lowering architecture; recipes are machine-evaluable declarative specifications, not executable knowledge. SSSOM, STRM, OSCAL, CSV, and Markdown are serializations. ZIP files, folders, and git repositories are carriers, and only become packages when manifest semantics define the package.

The stack at a glance

Every layer, the convention(s) it runs on, and whether we built it or adopted / combined an existing standard. The chips are links — click any term you don’t recognize to jump to its definition. Data flows top to bottom; the Tier 1 contract (accent border) is the load-bearing middle. Crosswalker is general-ontology: GRC/compliance is the primary use case (the vast majority of usage), not the only one — so domain-specific pieces are marked (dashed) as use-case examples, not core architecture.

we builtadopted / combined

Sources · Tier 0

your data, any structured format — CSV · XLSX · JSON · OLIR · OSCAL

↓ parse the source

Parse

bounded transformation primitivesturn messy input into structured data · from RML · JSONata · dbt

↓ morph to vault shape

Morph

declarative recipe grammar · 5 mechanismstemplate filtersdecides which Obsidian primitive carries what

↓ address each concept

Address

render() → AddressCURIE identity · W3Ca concept → its file path, links, frontmatter

↓ build the Obsidian vault

Tier 1 · contract

Tier 1 schemamanaged / user_preserve_crosswalker provenanceSTRM + SSSOM · edges

Tier 1 = the canonical Markdown vault — the source of truth (what Obsidian reads, what git tracks, what survives plugin uninstall). The three-tier model (T0 source · T1 canonical · T2 cache) is established in system architecture.

↓ derive the cache projection

Cache · Tier 2

SQLite sidecar · sqlite-wasm + sqlite-vecdeletable speed cache — rebuilds from Tier 1

↓ query & read back

Query & output

data morphologyBases · Obsidianlenses / query-result projections

GRC use casethe three lenses — Control · Assurance · Risk — are the compliance-domain application of generic lenses and query-result projections; any ontology defines its own.

↓ export to standards

Export

OSCAL serializationSSSOM serializationSTRM serialization

The shape is the design: we built the morph (parse → recipe → render → contract) and the way you read it back (data morphology + lenses); we adopted proven standards wherever one existed (CURIE for identity, STRM + SSSOM for crosswalk semantics, OSCAL for export, Bases + SQLite for query). Composing standards instead of reinventing them is what keeps a Tier 1 vault interoperable.

Each layer → go deeper

The map as a table. The diagram chips above link to quick definitions; this table links down to the full page(s) — concepts, logs, registry — that go deep on each convention.

Layer	The convention	Built / adopted	Go deeper
Parse — source → structured data	transformation primitives (≈40, closed catalog)	built (from RML · JSONata · dbt)	ETL and import · import-engine-design log
Morph — structured data → vault shape	the recipe grammar (5 layout mechanisms — source: spec/recipe.schema.json mechanism enum — × layout × also_emit × graph_edges)	built	Mapping into Obsidian · hierarchy primitives · Ch 22
Address — concept → place + links	render(Recipe, ConceptIdentity) → Address + 10 template filters	built	target-structure synthesis
Identity	CURIE / ConceptIdentity	adopted (W3C)	terminology · CURIE
Contract — what lands on disk	Tier 1 schema · managed/user_preserve · _crosswalker provenance	built	v0.1 schema spec · the managed/user_preserve split
Crosswalk semantics	STRM predicates + SSSOM metadata	adopted / combined	STRM · SSSOM · foundation synthesis
Cache	Tier 2 SQLite projector	adopted (sqlite-wasm · sqlite-vec)	embedded vs server · Ch 24 substrate synthesis
Output — questions → pictures	data morphology + Bases + lenses/query-result projections	built (morphology) · adopted (Bases)	data morphology · view shapes — GRC example: the lenses
Export	OSCAL · SSSOM · STRM serialization writers	adopted serialization standards	roadmap v0.1.7

The pattern across the stack is not that every artifact is a DSL. Each role has an explicit contract: recipes are machine-evaluable declarative specifications, schemas validate canonical records, serializations represent exchanges, and renderers or projectors execute bounded operations. Those contracts keep the recipe schema decoupled from the engine, the engine from the Tier 1 schema, and the cache substrate from the schema. That decoupling is the modularity goal made concrete.

Related

• Artifact roles and authority — operation, recipe, serialization, carrier, and package distinctions used on this page
• System architecture — the same stack as components + data flow (tiers, what-reads-what, code refs)
• Mapping into Obsidian — the front half, deep: how external data becomes vault primitives
• Data morphology — the back half, deep: the output / query language
• ETL and import — schema-as-primitive + the transformation-primitive catalog
• The four Obsidian primitives — the structural targets
• v0.1 schema spec — the Tier 1 contract
• Terminology — CURIE, recipe, render, tiers, STRM, SSSOM