Crate purrdf

Expand description

Umbrella Rust API for PurRDF.

This crate is the user-facing facade and the single dependency a downstream needs: it re-exports the RDF 1.2 implementation surface from purrdf_rdf at the root, and carries every other published crate under a stable module, so anything a consumer legitimately imports is reachable from purrdf alone — never by reaching into a sub-crate.

Module	Sub-crate(s)
(root)	`purrdf_rdf` — core types, codecs, GTS/text adapters
`columnar`	`purrdf_columnar` (five-table Parquet codec)
`gts`	`purrdf_gts` (container engine) + the `purrdf_rdf` GTS adapter
`sparql`	`purrdf_sparql_eval` + `purrdf_sparql_algebra` + `purrdf_sparql_results`
`shapes`	`purrdf_shapes` (SHACL)
`shex`	`purrdf_shex` (ShEx 2.1)
`entail`	`purrdf_entail` (RDFS / OWL-RL / OWL-Direct / RIF entailment)
`datalog`	`purrdf_datalog` (the semi-naive engine `entail`’s public types carry)
`geo`	`purrdf_geo` (GeoSPARQL 1.1 geometry, `geof:` functions, query rewrite)
`text`	`purrdf_text` (deterministic full-text search over RDF 1.2 literals)
`validate`	`purrdf_validate` (SARIF 2.1.0 reporting boundary)
`slice`	`purrdf_slice`
`viz`	`purrdf_rdf::viz`
`xsd`	`purrdf_xsd`
`iri`	`purrdf_iri`
`events`	`purrdf_events`

Consumer-config types are surfaced at the root (SliceVocab, Namespaces, StatementMetadataVocab) and unified behind a single OntologyProfile a downstream builds once (see profile). The explicit ontology-aware developer-schema contract (SchemaCompileRequest, SchemaSurfaceMode, and compile_schema) is also available at the root.

§Example

Every step below goes through the purrdf facade alone — a downstream never reaches into a sub-crate:

use purrdf::prelude::*;

// Parse RDF 1.2 Turtle into a frozen dataset through the umbrella facade.
let turtle = r#"
    @prefix ex: <https://example.org/> .
    ex:cat ex:says "meow" .
"#;
let dataset = purrdf::parse_dataset(turtle.as_bytes(), "text/turtle", None)
    .expect("valid Turtle");
let view: &RdfDataset = &dataset;
assert_eq!(view.quad_count(), 1);

// The zero-dependency IRI leaf is reachable under a stable module.
let iri = purrdf::iri::parse("https://example.org/cat").expect("valid IRI");
assert_eq!(iri.as_str(), "https://example.org/cat");

// Parse a ShEx 2.1 schema and name a SPARQL results serialization — both
// from the same facade.
let schema = purrdf::shex::parse_shexc(
    "PREFIX ex: <https://example.org/>\nex:Cat { ex:says . }",
    None,
)
.expect("valid ShExC");
assert!(!format!("{:?}", purrdf::sparql::SparqlResultsFormat::Json).is_empty());
let _ = schema;

§The document base

Both RDF legs of this facade take a document base, and it is the SAME parameter on each: the trailing Option<&str> of parse_dataset and of serialize_dataset_to_format. The Rust surface is therefore exactly as capable as the Python, WebAssembly, and C ones — a consumer never drops to a sub-crate to resolve or emit a relative IRI.

Ingress. parse_dataset resolves relative references against the supplied base for the syntaxes whose grammar admits them (NativeRdfFormat::admits_relative_iri). An in-document base (Turtle @base, xml:base, JSON-LD @context.@base) overrides the caller’s, per RFC-3986 §5.1.
Egress. serialize_dataset_to_format writes the base directive and relativizes against it for the syntaxes that can express one (NativeRdfFormat::emits_base); the rest emit absolute IRIs. That is the only spelling those grammars admit, decided once from the format registry.
No base is a hard failure, never a fabricated one. PurRDF is handed bytes and has no retrieval IRI, so it never invents a base from the filesystem or a URL. A relative reference with nothing in scope fails with the shared diagnostic code iri-relative-no-base; a supplied base that is not absolute fails on both legs.

The types for building and interpreting a base — iri::BaseIri, iri::BaseScope, iri::BaseOrigin, and iri::IriError (whose diagnostic_code owns those strings for the whole workspace) — are reachable under iri, so naming one never costs a second dependency.

use purrdf::{NativeRdfFormat, parse_dataset, serialize_dataset_to_format};

let base = "https://example.org/base/";

// Ingress: a relative subject resolves against the base.
let doc = "<rel> <https://example.org/p> <https://example.org/o> .\n";
let dataset = parse_dataset(doc.as_bytes(), "text/turtle", Some(base))?;
assert_eq!(dataset.quad_count(), 1);

// Egress: Turtle can express a base, so it is written and relativized against.
let turtle = serialize_dataset_to_format(&dataset, NativeRdfFormat::Turtle, Some(base))?;
let turtle = String::from_utf8(turtle.bytes).expect("utf-8");
assert!(turtle.contains("@base <https://example.org/base/> ."));

// N-Triples cannot, so the same base yields absolute IRIs rather than an error.
let nt = serialize_dataset_to_format(&dataset, NativeRdfFormat::NTriples, Some(base))?;
let nt = String::from_utf8(nt.bytes).expect("utf-8");
assert!(nt.contains("<https://example.org/base/rel>"));

// With nothing in scope the relative reference hard-fails; no base is invented.
let error = parse_dataset(doc.as_bytes(), "text/turtle", None).expect_err("no base");
assert_eq!(error.code, "iri-relative-no-base");

Re-exports§

pub use profile::OntologyProfile;
pub use profile::ReifierVocab;
pub use reasoning::ClosureRelations;
pub use reasoning::GovernedEntailment;
pub use reasoning::QueryEntailment;
pub use reasoning::QueryEntailmentPlan;
pub use reasoning::ReasoningError;
pub use reasoning::RelationRebuilder;
pub use reasoning::query_with_entailment;
pub use reasoning::query_with_entailment_governed;

Modules§

backend: Narrow purrdf backend traits (P2d).
blank_label: Exact label alphabets for the syntax this workspace emits – blank-node labels, XML NCNames, XML character data – plus the deterministic (label, scope) <-> token codec (encode_blank_label / decode_blank_label) every serializer and every text parser goes through, so an out-of-alphabet label never becomes an unreadable document and two distinct blank nodes never become one.
bundle: The self-describing bundle resource layer (S3).
capture_support: Shared corpus-classification helpers for the native golden-capture binary.
columnar: Bidirectional, byte-deterministic five-table Parquet codec.
content_store: Content-addressed blob store for the self-describing bundle (S3).
datalog: The deterministic semi-naive Datalog engine (purrdf_datalog) that entail evaluates its calculi on.
dataset_io: RDF text/bytes ingress into the frozen RdfDataset IR.
dataset_view: The static, allocation-free read view over an RDF dataset (purrdf P2, ). See docs/design/purrdf-backend-contract.md.
describe: Per-subject subgraph extraction — the Symmetric Concise Bounded Description (SCBD) of a resource.
diagnostic: Structured diagnostics: severity, source/GTS locations, conversion losses, and the RdfDiagnostic record callers translate to their reporting layer.
entail: Native, wasm-clean entailment (purrdf_entail): RDFS / OWL-RL forward materialization plus the OWL-Direct and RIF entry points, over the frozen IR.
events: The zero-dependency streaming RDF event model.
fno: Native FnO (W3C Function Ontology) typed model + serializer.
geo: GeoSPARQL 1.1 (purrdf_geo): exact, float-free WKT and GeoJSON geometry, the geof: function family registered on sparql’s scalar seam, and feature-level query rewrite registered on its property-function seam — every IRI supplied by the caller.
gts: GTS: the container engine (purrdf_gts) plus the RDF-level GTS adapter from purrdf_rdf (read_graph, flattened_dataset_from_bytes, …).
gts_certify: GTS streamable-compaction certificates (GTS-SPEC §10.1/§10.2, Task 5).
gts_compose: The pyo3-free GTS snapshot compose core (P6).
gts_dict_vectors: The fixed sources and authoring recipes behind the frozen in-band-dictionary corpus vectors (vectors/30-dict-rawcontent.gts, vectors/31-dict-trained.gts, vectors/32-dict-rsyncable.gts, vectors/33-multi-dict.gts).
gts_view: Rust-owned read-side view over a folded GTS graph.
gts_write: Write a frozen RdfDataset into a deterministic GTS byte stream.
ir: The immutable, value-interned RDF 1.2 dataset IR (C1).
iri: IRI parsing, resolution, and CURIE expansion/contraction.
lookaside: Structured non-triple material (RdfLookaside) that travels with an RDF store: typed sidecar resources, metadata entries, segment/blob records, suppressions, opaque nodes, and signature records.
loss: The machine-readable RDF↔GTS loss ledger (C0).
model: The owned RDF 1.2 value model: terms, literals (including base-direction literals), triples, quads, reifiers, and statement annotations.
native_codecs: Native RDF text codecs (S3).
native_quads: Native RdfQuad ⇄ RdfDataset conversions.
prelude: The common umbrella surface, for use purrdf::prelude::*;.
profile: One consumer-config shape for every namespace-bound emitter.
projections: Deterministic graph/tabular/research-object projection foundations and codecs. Deterministic, caller-configured RDF 1.2 graph, tabular, dataset-description, and research-object projections.
provenance: Generic provenance sidecar for the immutable RDF 1.2 dataset (S2).
reasoning: Entailment-aware SPARQL orchestration over the native PurRDF engines.
shapes: SHACL shape support.
shex: ShEx 2.1 schema parsing, serialization, and validation.
slice: Native slice catalog and dataset-wrapper support.
sparql: SPARQL 1.1/1.2: parser + algebra (purrdf_sparql_algebra), evaluator (purrdf_sparql_eval), and results serialization (purrdf_sparql_results).
sssom: Native SSSOM (Simple Standard for Sharing Ontology Mappings) codec.
statements: Native OWL axiom-annotation ↔ RDF 1.2 statement codec — the lead writer.
store: Dataset/import capability flags (RdfStoreCapabilities).
text: Deterministic full-text search over RDF 1.2 literals (purrdf_text): an in-memory inverted index, exact fixed-point BM25 ranking, and the relations a caller registers on sparql’s property-function seam under its own IRIs.
turtle: Native RDF 1.2 Turtle emitter for crate::store stores.
turtle_normalize: A canonical, review-friendly Turtle serializer over the purrdf IR.
turtle_render: The canonical, review-friendly Turtle renderer over the purrdf IR — the oxigraph-free half of the on-disk normalizer.
ustar: Shared USTAR (tar) codec — byte-deterministic writer + reader.
validate: The SARIF 2.1.0 reporting boundary (purrdf_validate): validate a shapes+data pair to a source-traced, byte-deterministic SARIF log.
viz: Statement-centric RDF 1.2 visualization projection and SVG export support.
xsd: XSD datatype value spaces and operations.

Macros§

smallvec: Creates a SmallVec containing the arguments.

Structs§

ArtifactId: Opaque id for a packaged artifact within a unit (module file, shapes file, mapping, query, …). Runtime-only (S0.5).
ArtifactIdentity: Exact identity of a model, engine, tokenizer, or manifest.
ArtifactIndex: Index of ArtifactRecords with lookup by ArtifactId, by logical path, and by UnitId.
ArtifactInterner: Interner for ArtifactIds — maps a logical artifact path to a dense numeric id. The path is a string the caller controls (e.g. a repo-relative file path or a content-addressed digest); the kernel does not interpret it.
ArtifactRecord: One packaged artifact: a content-addressed reference into the ContentStore, with no inline payload bytes.
ArtifactRoot: Integrity root over the canonical PURREMB header and section directory.
AssertionOccurrence: One physical assertion: the pair (unit, artifact) that asserted the quad identified by quad (a QuadHandle into the associated RdfDataset).
Attribution: A structured attribution: which compilation unit played which role in producing a finding, derivation, or SHACL result (S0.3 / §9).
BlankScope: Blank-node scope. Participates in the interning key (C0.2): two blank nodes from different scopes are distinct even with the same label; two blank nodes in the same scope with the same label are the same node. 0 = default/global scope; > 0 = a per-segment scope assigned by the streaming importer.
BudgetExceeded: The n-degree search’s call/permutation budget (RDFC_CALL_LIMIT) was exhausted before the dataset canonicalized — a pathologically symmetric blank graph (adversarial input, not a legitimate large dataset: a non-symmetric graph of any size stays well under budget). Returned by try_canonicalize/try_canonicalize_with instead of the panic that canonicalize/canonicalize_with raise for trusted callers.
CanonicalMetadataInput: Complete typed input for the eight non-matrix PURREMB metadata sections.
CanonicalMetadataSections: Canonically encoded non-matrix sections supplied to both writer paths.
Canonicalized: The result of canonicalizing a dataset.
CertifiedPurrpckSource: Independently certified attachment to one exact .purrpck byte string.
ChunkingContractId: Identity of the exact chunking-stage contract.
CompiledJsonLdContext: Immutable compiled JSON-LD 1.1 active and inverse context.
ConstructViewConfig: Mandatory bounds and query text for a whole-dataset SPARQL CONSTRUCT view.
ConstructViewProjection: Materialized result of one bounded whole-dataset CONSTRUCT view.
ContentDigest: A content id: the SHA-256 digest of a blob’s bytes.
ContentStore: A content-addressed blob store: bytes keyed by their SHA-256 ContentDigest.
ContractExtension: One caller extension field retained in a canonical contract.
CorpusTarget: Corpus-manifest subject.
CroissantConfig: Mandatory caller-owned configuration for the Croissant 1.1 codec.
CroissantVocabulary: Complete caller-owned compact-term binding for Croissant.
CsvwCell: One annotated table cell.
CsvwColumn: One column description in a CSVW table schema.
CsvwConfig: Mandatory identity and resource policy for CSVW processing.
CsvwContext: Caller-owned JSON-LD context identity and compact-IRI prefix map.
CsvwDatatype: CSVW datatype and its value-space facets.
CsvwDialect: A normalized CSVW dialect.
CsvwExactProjection: Exact, lossless RDF 1.2 → CSVW result.
CsvwExactReadOutcome: Exact CSVW → RDF 1.2 result.
CsvwForeignKey: A table-schema foreign-key constraint.
CsvwInheritedProperties: Properties inherited by table, schema, and column descriptions.
CsvwInput: Complete in-memory resource set for one CSVW operation.
CsvwMappedTableGroup: Typed result that a caller-owned RDF-to-table mapping must produce.
CsvwNumericFormat: A CSVW numeric-format object.
CsvwReadOutcome: Result of processing a complete CSVW resource package.
CsvwReference: A foreign-key reference target.
CsvwRow: One annotated table row.
CsvwSchema: A normalized CSVW table schema.
CsvwTable: One annotated CSVW table and its parsed rows.
CsvwTableGroup: A normalized CSVW table group.
CsvwTermsColumn: One caller-owned RDF predicate mapped to one ordered CSVW column.
CsvwTermsConfig: Complete mandatory configuration for the write-only csvw-terms profile.
CsvwTermsIdentityColumn: Visible subject-identity column shared by every row in one table.
CsvwTermsLimits: Portable execution ceilings specific to curated wide tables.
CsvwTermsProjection: Curated CSVW package, normalized table model, and complete runtime ledger.
CsvwTermsReport: Deterministic execution counts for one curated terms projection.
CsvwTermsSelector: Caller-supplied RDF-type and subject-namespace membership test for one table.
CsvwTermsTable: One curated entity table and its complete mapping policy.
CsvwTransformation: A CSVW transformation description retained by the annotated model.
CsvwValue: A normalized value produced by parsing one CSV cell.
CsvwVocabulary: Caller-supplied RDF namespaces used by the CSVW conversion algorithm.
CsvwWarning: Deterministic non-fatal CSVW diagnostic.
CsvwWriteOutcome: Result of deterministically writing one normative CSVW table group.
CsvwWritePlan: Mandatory mapping from resource identities to safe package paths.
DataCiteConfig: Mandatory caller-owned DataCite 4.6 schema and semantic configuration.
DataCiteControlledValues: Caller-selected DataCite 4.6 controlled values and identifier policy.
DatasetDiff: A structural diff between two datasets, for test diagnostics. Counts only; the blank-aware verdict is datasets_isomorphic.
DatasetProvenance: The provenance sidecar for one RdfDataset.
DatasetSink: An RdfEventSink that folds a permissive ingestion event stream into a frozen RdfDataset, tolerant of forward references (two-phase; see the module docs).
DcatConfig: Mandatory caller-owned DCAT 3 configuration.
DcatRdfConfig: Mandatory output syntax and source policy for the dcat-rdf profile.
DcatRdfMappingConfig: Mandatory target-core vocabulary and output bound for mapped DCAT RDF.
DcatVocabulary: Complete caller-owned compact-term binding for the DCAT application profile.
DerivedIndex: One opaque, rebuildable derived index and its exact guard commitment.
DocumentTarget: External UTF-8 document subject.
EffectiveMatrixView: A matrix paired with one compatible fixed or Matryoshka projection.
EffectivePrefix: One declared effective prefix in an embedding family.
EffectiveSpace: One effective vector space in a fixed or Matryoshka family.
EffectiveSpaceView: Borrowed view of one effective vector-space record.
EmbeddingBuilder: Canonical in-memory PURREMB builder.
EmbeddingFamily: Derived, canonical representation of one embedding family.
EmbeddingFamilyContract: Complete generation contract for one fixed or Matryoshka embedding family.
EmbeddingStreamWriter: Bounded-memory canonical writer over an initially empty seekable output.
EmbeddingTarget: Canonical target plus optional retained identity bytes and pack-local ordinal.
EmbeddingVerificationReport: Counts and resident proof produced by full artifact verification.
EmbeddingView: Bounds-safe borrowed view over one structurally canonical PURREMB artifact.
EncodedArtifact: Result of canonical in-memory file assembly.
ExtensionSection: One caller extension section retained byte-for-byte by the writer.
ExtensionTarget: Caller-defined extension target.
ExternalBinding: One exact external-artifact binding with its derived identity.
ExternalBindingContract: Caller-supplied semantics for an exact external artifact.
ExternalBindingId: Identity of one exact external-artifact binding.
ExternalBindingIdentity: Inputs to the external-binding identity fold.
ExternalBindingView: Borrowed external-artifact binding record.
ExternalContractDigest: Digest of one generic external-artifact contract.
F32Scalars: Portable little-endian f32 decoder that rejects non-finite values lazily.
F64Scalars: Portable little-endian f64 decoder that rejects non-finite values lazily.
FamilyContractDigest: Digest of one canonical vector-family contract block.
FamilyId: Identity of a complete embedding family.
FamilyView: Borrowed view of one vector-family record.
FnFunction: One fno:Function node (always typed fno:Function; any additional rdf:type IRIs — e.g. the consumer’s projection-function class for the projection catalog — come from FnFunction::kind_types).
FnImpl: One fno:Implementation node (one per profile .rq).
FnMapping: One fno:Mapping node linking a function to one profile’s implementation.
FnOutput: The fno:Output node of a function.
FnParam: One globally-deduped fno:Parameter node.
FnParamMapping: One fnom:PropertyParameterMapping (a parameter ↦ a SPARQL variable).
FnReturnMapping: One fnom:DefaultReturnMapping (the function output ↦ a SPARQL variable).
FnoCatalog: The fully-resolved FnO catalog the purrdf-slice emitter assembles and serializes here.
FrictionlessConfig: Mandatory caller-owned Frictionless Data Package v1 configuration.
FrozenDatasetSource: An RdfEventSource that replays an already-frozen RdfDataset into any RdfEventSink: a term event per term in TermId order (declares-before- reference), then quad / reifier / annotation events.
GtsBundle: The frozen RDF 1.2 hot graph plus its out-of-band envelope.
GtsCodecBackend: The native codec backend: a codec-only RdfParserBackend + RdfSerializer over the purrdf-gts text codecs. Holds no state and references no oxigraph Store.
HandleEntry: A typed handle: a pipeline-side payload H paired with the PINNED ContentDigest of the named graph it projects.
IndexCoordinates: Exact typed coordinates guarded by one opaque index.
IndexGuardContract: Complete canonical contract guarding one opaque derived index.
IndexGuardDigest: Digest of one opaque derived-index guard contract.
IndexGuardView: Borrowed opaque derived-index guard and optional inline payload.
IndexId: Identity of one guarded opaque derived index.
IndexIdentity: Inputs to the opaque derived-index identity fold.
IndexLossContract: Explicit approximation and vector-loss contract for an opaque index.
JsonLdContextLimits: Fixed resource ceilings for context decoding and compilation.
JsonLdContextRegistry: Immutable collection of caller-supplied context documents keyed by absolute IRI.
JsonLdSerializeOptions: Closed version-1 JSON-LD/YAML-LD serialization request.
JsonLdTermDefinition: Compiled definition for one term or keyword alias.
JsonLdTermSelection: Ordered inverse-context preferences for one IRI-compaction decision.
L2F32Scalars: Allocation-free deterministic-L2 f32 projection iterator.
L2F64Scalars: Allocation-free deterministic-L2 f64 projection iterator.
LossEntry: One enumerated conversion loss between two representations.
LossLedger: An ordered, deterministic set of LossEntry for one conversion direction (or the combined matrix).
LpgAnnotation: Exact RDF 1.2 statement annotation carried by the canonical LPG model.
LpgConfig: Mandatory policy and resource boundary for the canonical LPG mapping.
LpgEdge: Canonical directed LPG edge with exact RDF statement identity.
LpgExecutionLimits: Mandatory fail-fast execution bounds for RDF-to-LPG mapping.
LpgGraph: Canonical deterministic LPG plus complete RDF 1.2 reversal sideband.
LpgLabel: One RDF type-like statement lowered to a native LPG label.
LpgLiftOutcome: Result of canonical LPG→RDF lifting.
LpgNode: Canonical LPG node with exact RDF term identity.
LpgPackageProjection: A direct RDF projection into one deterministic LPG carrier package.
LpgProgress: Monotonic progress snapshot for mapping and artifact emission.
LpgProjection: Result of RDF→LPG projection.
LpgProjectionReport: Exact counters from one RDF-to-LPG mapping.
LpgProperty: One RDF literal statement lowered to a native LPG property.
LpgRdfQuad: Exact RDF 1.2 statement identity retained beside a native LPG construct.
LpgReifier: Exact RDF 1.2 reifier binding carried by the canonical LPG model.
LpgStreamProjection: Result of direct RDF-to-artifact-sink LPG projection.
MatrixCommitment: A fully derived stored-matrix commitment used by the streaming writer.
MatrixContentDigest: Domain-separated digest of one stored matrix’s exact scalar bytes.
MatrixId: Identity of one stored matrix over a family and target set.
MatrixInput: One unordered matrix accepted by EmbeddingBuilder.
MatrixRow: One target-associated row accepted by the unordered in-memory builder.
MatrixView: Borrowed authoritative dense matrix.
MutableDataset: A copy-on-write mutable RDF dataset (purrdf P5). Branches cheaply off a shared frozen base; records mutations as an append delta + a suppression set; and compacts back to a frozen RdfDataset via freeze.
Namespaces: The caller-supplied namespace table driving ALL IRI compaction, $defs keying, and @type discrimination — for BOTH the schema emitter (compile) and the instance projector (crate::instance).
OboDomainRangeAxiom: Aggregated domain/range declaration for one property.
OboEdge: Basic OBO Graphs edge.
OboEquivalentNodesSet: Set of mutually equivalent named nodes.
OboExistentialRestriction: Named existential restriction in one logical definition.
OboGraph: One OBO Graphs 0.3.2 graph.
OboGraphDocument: OBO Graphs 0.3.2 graph document.
OboGraphsConfig: Mandatory graph identity, vocabulary, and resource bounds for OBO Graphs.
OboGraphsProjection: Result of projecting an RDF 1.2 dataset into the OBO Graphs 0.3.2 view.
OboGraphsVocabulary: Complete caller-supplied semantic vocabulary for RDF→OBO Graphs 0.3.2.
OboLogicalDefinitionAxiom: Named-class equivalence to an intersection of genera and existentials.
OboMeta: OBO Graphs 0.3.2 metadata, including nested axiom metadata.
OboMetadataRoles: Caller-owned OBO metadata roles.
OboNode: Basic OBO Graphs node.
OboOwlRoles: Caller-owned RDFS and OWL semantic roles used by the projection.
OboPropertyChainAxiom: One OWL property-chain axiom.
OboPropertyValue: One metadata property value in the 0.3.2 object model.
OboRdfRoles: Caller-owned RDF and XML Schema roles used by the OBO Graphs projection.
OboSynonym: One OBO synonym property value.
OboXref: One OBO cross-reference property value.
OfflineJsonLdContext: Caller-owned, locally interpreted JSON-LD context.
OkfBodySection: Caller-authored Markdown body section backed by one or more predicates.
OkfBundle: A deterministic, validated in-memory OKF Markdown bundle.
OkfCategory: Caller-authored category metadata and classifier.
OkfConceptSelector: Caller-supplied type-set and IRI-prefix classifier for one OKF category.
OkfConfig: Mandatory caller-owned OKF vocabulary and frontmatter profile.
OkfError: A typed hard failure from OKF configuration, parsing, lifting, or writing.
OkfFieldMapping: Predicate set, cardinality, and value policy for one output field.
OkfFrontmatterMappings: Complete mapping for standard and producer-defined OKF frontmatter.
OkfGenerationConfig: Complete mandatory configuration for the write-only okf-terms projection.
OkfGenerationReport: Deterministic execution counts for one OKF terms projection.
OkfIndexConfig: Caller-authored root-index and in-band projection-fidelity prose.
OkfLinkSection: Caller-authored Markdown link section backed by RDF predicates.
OkfProjection: Caller-curated OKF bundle, filesystem-free package, counts, and located losses.
OkfReadOutcome: Report from lifting an OKF bundle through an RDF event sink.
OkfWriteOutcome: Result of projecting an RDF 1.2 dataset into an OKF Markdown bundle.
OkfWriter: Event receiver for the RDF-dataset → OKF projection.
OriginSetId: Opaque id for an interned set of origins. Two quads with the same set of (UnitId, ArtifactId) pairs share an OriginSetId. Runtime-only (S0.5).
OriginSetInterner: Interner for OriginSetIds — maps a canonical sorted set of (UnitId, ArtifactId) pairs to a dense numeric id.
PackBuilder: The offline factory writer: assembles a self-contained, byte-deterministic pack file from an RdfDataset. See the module docs for the exact on-disk layout.
PackDigest: A verified SHA-256 purrdf-rdfc12 digest: the output of verify_pack on success.
PackId: The DatasetView id a PackView-backed read mints: a thin, niche-optimized wrapper around the pack dictionary’s unified [PackTermId] (see the module docs). Meaningful only within the PackView that resolved it (C0.8) — a durable identifier must resolve the term to its RDF value rather than retain a PackId.
PackView: The zero-copy, borrowed reader over PackBuilder::build_bytes’s output. Owns the decoded [PackDict] (an arena the dictionary’s PFC sections are decompressed into once, at open time) and borrows the bitmap-triples and side-table sections directly from the input buffer — see the module docs for the exact on-disk layout and the fail-closed verification from_bytes performs.
PageFault: A page could not be materialized as part of the requested snapshot.
PageGeneration: The immutable provider snapshot to which page translations and byte metadata belong.
PageId: A dense page ordinal. Pages of a PagedDataset are numbered 0..page_count and iterated in ascending PageId order.
PageMaterialization: One atomic page-materialization result.
PagePart: One page’s pre-built seal metadata, the unit of PagedDataset::from_parts/to_parts.
PageTranslation: The local↔global term-id map for a single page of a PagedDataset.
PagedDataset: A reference demand-paged dataset composing many frozen RdfDataset pages into one logical DatasetView keyed on GlobalTermId.
PagedQuadOverlap: The offending quad of a PagedFreezeError::QuadOverlap refusal: the two pages that share it, which composed stream it belongs to, and the quad resolved to dataset-independent TermValues.
PagedQueryEvidence: Deterministic evidence accumulated by one paged query operation.
PagedQueryLimits: Exact resource ceilings for one PagedQueryView.
PagedQueryView: An operation-local, fallible DatasetView over a sealed PagedDataset.
ParseOptions: Runtime options for parse_dataset_with.
ParseOutcome: Everything one parse of one document produced.
PipelineBundle: The pipeline carrier: the frozen hot graph plus its out-of-band material and a typed-handle lane.
ProjectionArchive: Deterministic USTAR projection plus its always-computed runtime loss ledger.
ProjectionCommitment: A fully derived effective-projection commitment.
ProjectionContentDigest: Domain-separated digest of one effective matrix projection.
ProjectionError: Typed hard failure from a graph or tabular projection.
ProjectionId: Identity of one effective matrix projection.
ProjectionLift: Dataset reconstructed from a bidirectional projection carrier.
ProjectionLimits: Mandatory resource bounds shared by projection writers and readers.
ProjectionPackage: A deterministic, validated, filesystem-free projection artifact package.
ProjectionPackageSink: In-memory adapter used by the materializing ProjectionPackage APIs.
ProjectionSpec: One effective leading-prefix projection declared for a matrix family.
ProjectionView: Borrowed effective projection record.
QuadHandle: A handle identifying a pushed quad by its dense (deduplicated) ordinal, used to attach a source location sparsely. Like TermId, it is local to one frozen dataset and is not persistent or merge-stable.
QuadIds: A small Copy quad row in term ids, for ID-native consumers. g == None is the default graph.
QuadPatternCursor: An owned, row-materialization-free cursor over one indexed quad pattern.
QuadRef: A borrowed, resolved quad view: each position is a TermRef borrowing into the dataset’s term table. No allocation, no clone per quad.
QuadValues: An owned, dataset-independent quad value — the argument type of DatasetMut::insert/remove/contains.
RdfAnnotation: RDF 1.2 statement annotation.
RdfAnnotationTarget: RDF 1.2 annotation target.
RdfBlobOrigin: Where a blob’s payload bytes can be fetched from.
RdfBlobRecord: A content-addressed reference to a blob that travels with an RDF store.
RdfBundle: The self-describing, repo-free bundle: dataset + provenance + unit catalog + artifact index + the actual blob bytes.
RdfDataset: The immutable, frozen RDF 1.2 dataset. Constructed only via RdfDatasetBuilder::freeze.
RdfDatasetBuilder: The fallible builder that interns terms, accumulates structure, and freezes into an immutable Arc<RdfDataset>.
RdfDatasetTarget: Certified RDF dataset subject.
RdfDescriptionProjection: One frozen RDF description graph and its deterministic packaged serialization.
RdfDiagnostic: Structured RDF diagnostic. Callers translate this to their reporting layer.
RdfEnvelope: Out-of-band material that travels with an RdfDataset but is not part of the hot graph (C0.6).
RdfGraphTarget: Default or named RDF graph target.
RdfLiteral: An RDF literal, including RDF 1.2 language direction when available.
RdfLocation: Concrete or logical location attached to an RDF diagnostic.
RdfLookaside: Structured non-triple material that travels with an RDF store.
RdfLookasideResource: A typed sidecar resource such as SHACL, ShEx, docs, logic, schemas, or queries.
RdfMetadataEntry: A scoped key/value metadata entry carried alongside the triples.
RdfOpaqueNodeRecord: A frame preserved as an opaque node: its content was not decoded, only its identity and public envelope survive.
RdfParseRequest: RDF parser request. Formats are named by media type or local format id at the contract boundary so the core trait does not leak an oxigraph enum.
RdfQuad: Owned RDF 1.2 quad with optional adapter/source context.
RdfReifier: RDF 1.2 reifier binding.
RdfReifierTarget: RDF 1.2 reifier-binding target.
RdfSegmentRecord: Per-segment facts recorded from the source GTS file.
RdfSerializeRequest: RDF serializer request. Formats are media types/local ids for the same reason as RdfParseRequest: the core trait must not expose an oxigraph enum.
RdfSignatureRecord: A frame signature record.
RdfStatementTarget: RDF 1.2 statement target.
RdfStoreCapabilities: Capability flags exposed by an RDF dataset/import boundary.
RdfSuppressionRecord: A suppress directive (GTS §11) carried through verbatim; decode its targets with RdfLookaside::suppression_targets.
RdfTriple: Owned RDF 1.2 triple. The model keeps triple-term subjects representable; downstream adapters decide whether a target store can encode them.
RdfcDigest: Claimed or verified RDFC SHA-256 bytes carried by PURREMB metadata.
RelationRange: Iterator over one target’s contiguous relation range.
RelationView: Borrowed structural relation.
ResearchActivity: Provenance activity connected to the research object.
ResearchAgent: Person, organization, or software agent used by a research object.
ResearchChecksum: Algorithm/value checksum pair.
ResearchDataset: Dataset-level research-object metadata and entity references.
ResearchField: Field definition in a Croissant-compatible record set.
ResearchObjectConfig: Shared source-vocabulary, identity, and resource policy.
ResearchObjectIdentity: Caller-owned data identity policy shared by all research-object profiles.
ResearchObjectModel: Canonical typed semantic pivot shared by every research-object codec.
ResearchObjectPackageProjection: Native-profile projection result before USTAR encoding.
ResearchObjectPolicy: Mandatory resource policy for common research-object interpretation.
ResearchObjectProjection: Common semantic projection and its always-computed runtime losses.
ResearchObjectReadOutcome: Native-profile reader result after caller-vocabulary RDF lift.
ResearchObjectRoles: Complete caller-owned RDF vocabulary binding for research objects.
ResearchRecordSet: Structured record set with deterministic inline JSON rows.
ResearchResource: File, distribution, or other data resource.
ResearchText: RDF literal identity retained by the common research-object model.
ReservedVocabulary: The input dataset carries an IRI in the profile’s RESERVED_NAMESPACE, which canonicalization refuses rather than lower alongside its own sentinels.
ResidentEmbeddingCertificate: Opaque proof that one exact resident byte range passed full verification.
RoCrateAssets: Bounded payload artifacts supplied by reference to the RO-Crate engine.
RoCrateConfig: Mandatory caller-owned configuration for RO-Crate 1.3.
RoCrateVocabulary: Complete caller-owned compact-term binding for RO-Crate.
SchemaClassPropertyCoverage: One catalogued property’s decision for one eligible class.
SchemaCompilation: Ontology-aware compilation output.
SchemaCompilationKey: Compiler-owned cache identity for one complete schema request.
SchemaCompileRequest: Complete input contract for ontology-aware schema compilation.
SchemaCoverageProvenance: One source axiom supporting a schema-surface decision.
SchemaCoverageReport: Deterministic audit manifest for ontology property coverage.
SchemaPropertyCoverage: Aggregate coverage for one ontology-declared property.
SectionKey: The canonical sort key for one section-directory entry.
SectionView: One borrowed PURREMB directory entry and its exact section bytes.
SegmentUnitMap: A set-valued mapping between GTS segments and compilation units (S0.7).
SerializeOptions: Policy options for serialize_dataset_with — the egress mirror of ParseOptions.
SerializeOutcome: Outcome of serializing an RdfDataset to a concrete RDF format through the native codecs (universal transcoder helper, ported onto the native path).
SkosClassRoles: Caller-owned RDF type and SKOS class roles.
SkosConfig: Mandatory identity, vocabulary, graph, and resource policy for RDF→SKOS.
SkosDocumentationRoles: Caller-owned SKOS documentation-property roles.
SkosLabelRoles: Caller-owned SKOS lexical-label and notation roles.
SkosProjection: Result of projecting an RDF 1.2 dataset into one SKOS concept-scheme view.
SkosRelationRoles: Caller-owned SKOS hierarchy, mapping, membership, and top-concept roles.
SkosSourceRoles: Complete caller-owned source interpretation for the RDF→SKOS projection.
SkosTargetRoles: Complete caller-owned target vocabulary for the emitted SKOS view.
SliceVocab: The caller’s slice-framework vocabulary: a namespace all framework term IRIs are derived from by concatenation ({ns}{localName}), the set of namespaces the caller’s slices mint ontology terms into, plus the CURIE prefix name used when emitting prefixed names.
SmallVec: A Vec-like container that can store a small number of elements inline.
SourceVerificationReport: Evidence returned after verifying the attached source pack.
SourceView: Exact source-pack attachment carried by the SOURCE section.
SpanTable: Opt-in mapping from a data-graph subject to the source Position where it was first asserted, plus the ordered list of every recorded (subject, position).
SparqlRequest: SPARQL operation request.
SssomColumnLayout: A validated TSV column declaration retained from a parsed SSSOM mapping set.
SssomDiagnostic: A single validation diagnostic, mirroring the sssom-py golden record shape {severity, type, message, instance, check}. code carries the golden’s type string; check carries the originating check name.
SssomMapping: A single SSSOM mapping (one TSV data row).
SssomMappingSet: A parsed SSSOM mapping set: header metadata, mappings, and document envelope.
SssomMeta: The SSSOM metadata header.
SssomSetComment: One validated, set-scoped comment in the SSSOM document envelope.
StageImplementation: Complete identity and parameters for one applied pipeline stage.
StatementMetadataVocab: The CALLER-SUPPLIED statement-metadata reification vocabulary the JSON-LD-star downcast emits.
SubsetPageProvider: A provider exposing a subset of another provider’s pages under fresh dense ids.
TargetId: Stable identity of one embedding target.
TargetIdentityDigest: Digest of one target kind’s canonical identity block.
TargetRelation: Built-in or caller-defined structural relation.
TargetSet: Canonical, nonempty target row set shared by one or more matrices.
TargetSetId: Identity of one sorted, duplicate-free target row set.
TargetSetView: Borrowed, nonempty target row set.
TargetView: Borrowed canonical target record.
TermId: Opaque term identity, LOCAL to one frozen RdfDataset. Deliberately NOT Serialize/Deserialize, not merge-stable, not meaningful across datasets (C0.8). Any consumer needing a durable identifier MUST resolve the term to its RDF value rather than retaining a TermId.
TextChunkTarget: Content-addressed document chunk with byte and scalar coordinates.
TlvEntryRef: Borrowed framing for one canonical TLV entry.
TlvIter: Allocation-free iterator over a structurally validated canonical TLV block.
TokenSpan: Family-scoped tokenizer span for a document or chunk target.
TokenSpanView: Borrowed family-scoped token span.
TransportError: A transport decode failure: the encoding that was applied and why it failed.
TransportReader: A Read stream whose transport wrapper is decoded INCREMENTALLY as the consumer pulls, rather than inflated into one buffer first.
UnitCatalog: Maps each UnitId to its UnitMetadata.
UnitId: Opaque id for a compilation/source unit (file set, import, generated graph, or runtime data input). Runtime-only: MUST NOT enter persistent serialization, cache keys, or derivation hashes (S0.5).
UnitInterner: Interner for UnitIds — maps a logical unit name to a dense numeric id.
UnitMetadata: Metadata describing one compilation unit (the kernel-generic projection of a slice / root ontology / import / generated graph / runtime input).
VectorSpaceId: Identity of one effective dimension and prefix policy in a family.
VoidConfig: Complete deterministic VoID dataset-description policy.
VoidDatasetPrefix: One deterministic IRI-prefix to dataset identity binding.
VoidExecutionLimits: Explicit compute and materialization bounds for VoID generation.
VoidExternalLinkMapping: Source-to-target predicate mapping for metadata-graph external IRI links.
VoidSourceRoles: Complete caller-owned source predicate binding for VoID extraction.
VoidStaticStatement: One caller-authored statement whose subject is the described dataset IRI.
VoidVocabulary: Complete caller-owned target vocabulary for VoID output.

Enums§

AppliedStage: Explicit pipeline-stage state.
ArtifactIdentityKind: Artifact cardinality carried by ArtifactIdentity.
AttributionRole: The role of a compilation unit in a structured attribution (S0.3 / §9).
BundleError: A hard error from RdfBundle::load. The loader never silently repairs; every malformed structure is a typed Err.
CanonError: Why canonicalization refused.
CanonHash: The RDFC-1.0 hash algorithm. SHA-256 is the default; SHA-384 is the spec’s alternative (RDFC-1.0 §3, exercised by W3C suite test075). EXTEND beyond oxrdf, which only offered SHA-256.
ContentStoreError: An error raised while validating or accessing a content-addressed blob.
CroissantRole: Semantic term required by the Croissant 1.1 adapter.
CsvwAction: Explicit CSVW processing entry point selected by the host.
CsvwDatatypeFormat: String or numeric-object datatype format.
CsvwMode: RDF conversion mode defined by the CSVW Recommendation.
CsvwTableDirection: Direction in which a table is presented.
CsvwTermsCardinality: Cardinality and deterministic multi-value encoding for one column.
CsvwTermsGraphSelection: Explicit RDF graph scope used to discover rows and column values.
CsvwTermsValueMode: Exact RDF object kind accepted by a curated column.
CsvwTextDirection: CSVW text direction for a column value.
CsvwTrim: Whitespace trimming policy from a CSVW dialect description.
CsvwWarningKind: Stable severity for a non-fatal CSVW metadata or row diagnostic.
DcatRdfSource: Complete source policy for native DCAT RDF.
DcatRole: Semantic compact term required by the DCAT 3 application-profile adapter.
DigestKind: A digest or typed identity that failed validation.
DimensionalityPolicy: Fixed or Matryoshka dimensionality contract.
DistanceMetric: Distance semantics for compatible vectors.
EffectiveF32Row: Logical f32 prefix values, raw or deterministically L2-normalized.
EffectiveF64Row: Logical f64 prefix values, raw or deterministically L2-normalized.
EmbeddingError: A fail-closed PURREMB format, identity, or verification error.
EmbeddingIntegrity: Integrity evidence currently associated with a borrowed view.
EmbeddingWriteError: A PURREMB streaming-write failure.
ExternalScope: Typed scope of one exact external-artifact binding.
ExternalScopeKind: Semantic type of an external-artifact binding scope.
GraphMatch: How a pattern query matches the graph slot of a quad.
GraphMatchValue: How a write-side pattern query matches the graph slot of a quad — the value-based twin of GraphMatch.
IndexBuildDeterminism: Declared determinism of an opaque index payload.
IndexDeterminism: Declared index-build determinism.
IndexPayloadStorage: Inline or detached storage for exact opaque index bytes.
IndexStorage: Opaque index storage mode.
IndexUseRole: Intended query-stage role of one index.
IriError: Why an IRI/URI string (or a reference-resolution / CURIE operation) failed.
JsonLdContainer: One JSON-LD 1.1 container mapping component.
JsonLdDirection: Base direction carried by a JSON-LD 1.1 context or term definition.
JsonLdNullable: Explicit nullable mapping in a JSON-LD term definition.
JsonLdSerializeMode: Explicit output mode for configured JSON-LD/YAML-LD serialization.
JsonLdTermSelectionKind: Inverse-context branch used while selecting a compact term.
JsonLdTypeMapping: Type coercion attached to a compiled JSON-LD term.
LiftProfile: Closed set of profiles accepted by the lift operation.
LpgGraphContext: Graph placement carried beside one RDF-origin LPG record.
LpgIriSelection: Exact allow/deny selection over absolute IRIs.
LpgNamedGraphSelection: Exact include/exclude selection over RDF named-graph terms.
LpgProgressPhase: Stable phase for one RDF-to-LPG mapping/package operation.
LpgPropertyAtom: Native scalar projection of one RDF literal.
LpgScope: Mandatory RDF input scope for LPG projection.
NativeRdfFormat: The RDF text serializations the native codec backend parses and serializes via the purrdf-gts codecs. This is the codec-selector enum that replaces oxigraph::io::RdfFormat’s use as a router across the workspace.
OboNodeType: OBO Graphs node kind.
OboPropertyType: OBO Graphs property kind.
OkfBodyStyle: Structural layout for values in a body or link section.
OkfBodyValueMode: How mapped body values are represented before Markdown layout.
OkfCardinality: Output cardinality and missing-value policy for one mapped field.
OkfGraphSelection: Explicit RDF graph scope used for concept discovery and mapped values.
OkfLinkPathStyle: Link-destination policy for selected concept documents.
OkfLinkStyle: Structural layout for one set of Markdown links.
OkfLinkTargetMode: Which link targets a section renders.
OkfPathStrategy: Deterministic bundle path identity strategy.
OkfResourceMapping: Caller-owned policy for the standard resource frontmatter field.
OkfTermRendering: Total textual rendering for arbitrary RDF 1.2 term values.
OkfValueMode: Typed scalar policy for one mapped RDF object.
OriginKind: The kind of a compilation unit. Generic — no SliceId here; the purrdf-slice layer interprets Slice-kind units by wrapping UnitId.
PackError: Why building or opening a pack container failed.
PageFaultKind: The typed reason a provider could not produce a valid page.
PagedFreezeError: Why sealing a provider into a PagedDataset failed.
PagedQuadTable: Which composed quad stream a PagedFreezeError::QuadOverlap refusal came from. The paged view exposes three cross-page streams that each assume disjoint pages and do NO cross-page dedup — the primary quads and the two RDF 1.2 side tables — so the seal enforces disjointness on all three, not just the primary quads.
PagedQueryError: The typed terminal error of a PagedQueryView.
PipelineBundleError: An error from attaching a typed handle to a PipelineBundle.
PrefixPostprocessing: Postprocessing applied to one leading-prefix space.
ProjectionConfig: Profile-tagged, caller-owned projection configuration.
ProjectionDirection: Portable RDF 1.2 literal base direction.
ProjectionErrorKind: Stable category for a projection failure.
ProjectionProfile: Closed set of RDF projection archive profiles.
ProjectionTerm: Dataset-independent, serialization-stable RDF 1.2 term identity.
ProvenanceError: An error from the provenance gate.
RdfListError: A malformed RDF Collection encountered while walking rdf:first/rdf:rest.
RdfLookasideKind: Known companion/index kinds. Unknown domains remain representable.
RdfMetadataValue: A structured metadata value mirroring the CBOR data model, so GTS metadata round-trips without loss.
RdfSeverity: Severity for RDF ingestion, conversion, and adapter diagnostics.
RdfTerm: Owned RDF 1.2 term.
RdfTermKind: RDF term category.
RdfTermTarget: Canonical RDF 1.2 term identity.
RdfTextDirection: RDF 1.2 base direction for directional language-tagged literals.
RelationKind: PURREMB v1 structural relation kinds.
ResearchRole: Semantic RDF role understood by the format-neutral research-object pivot.
ResearchValue: Scalar or reference value shared across research-object formats.
RoCratePackaging: Explicit RO-Crate package shape selected by the caller.
RoCrateRole: Semantic compact term required by the RO-Crate 1.3 adapter.
SchemaCompilationInput: Which graph failed canonicalization while deriving a schema cache key.
SchemaCompileError: Typed failures from ontology-aware schema compilation.
SchemaCoveragePrecision: Precision of a schema-surface decision.
SchemaCoverageStatus: Stable reason attached to one property/class coverage decision.
SchemaSurfaceMode: Selects the property/class surface projected into developer schemas.
SerializeGraph: Which graph(s) a serializer should emit.
SkolemError: Why skolemize / deskolemize refused.
SkosGraphSelection: Source graph selection for one SKOS concept-scheme view.
SourceFormat: A resolved source/target routing identity: a native RDF text syntax, the native pack container, or the GTS transport container.
SourceVerificationMode: Requested evidence level for an attached source pack.
SparqlResult: Materialized SPARQL result model independent of any concrete query engine.
SssomColumnLayoutError: A declared SSSOM TSV column-layout construction failure.
SssomCommentError: A typed set-comment construction failure.
SssomCommentKind: The lexical kind of a set-scoped SSSOM comment.
SssomCommentPlacement: Where a set-scoped SSSOM comment appears in the document envelope.
StatementLayer: Which RDF 1.2 statement-layer rows (reifier bindings + annotation triples) the emitted document carries.
TargetKind: Stable PURREMB v1 target-kind codes.
TermPosition: The quad position a refused reserved IRI was found in.
TermRef: A borrowed, resolved view of a term — mirrors InternedTerm but exposes &str slices borrowed from the dataset, so resolving a term performs no allocation and no clone. Triple components are returned as ids; resolve them recursively with RdfDataset::resolve if their values are needed.
TermValue: A dataset-independent term value — the lookup key for RdfDataset::term_id_by_value (purrdf P4).
TlvWireType: Canonical PURREMB TLV wire types.
TransportEncoding: A recognized transport encoding wrapping a payload byte stream.
VectorDtype: Authoritative dense scalar representation.
ViewOperationStatus: An atomic checkpoint of an operationally fallible dataset view.
VoidGraphSelector: Exact source graph selected for one VoID input role.
VoidRole: Semantic target role in a caller-owned VoID vocabulary.
VoidStaticValue: Caller-authored IRI or RDF literal on the described dataset.

Constants§

CANON_CORPUS_DIGEST: The content-addressed identity of this profile’s normative vector corpus.
CANON_PROFILE_ID: The identifier of the canonicalization profile this module implements.
CANON_PROFILE_VERSION: The version of CANON_PROFILE_ID this build implements.
CROISSANT_ARTIFACT: Sole artifact path in the canonical Croissant package.
CROISSANT_PROFILE: Closed Croissant projection profile identifier.
CROISSANT_ROLES: Every mandatory Croissant role in deterministic configuration order.
CSVW_TERMS_PROFILE: Stable loss-contract target for the curated terms profile.
DATACITE_ARTIFACT: Sole artifact path in the canonical DataCite package.
DATACITE_PROFILE: Closed DataCite projection profile identifier.
DCAT_ARTIFACT: Sole artifact path in the canonical DCAT package.
DCAT_PROFILE: Closed DCAT projection profile identifier.
DCAT_ROLES: Every mandatory DCAT role in deterministic configuration order.
FRICTIONLESS_ARTIFACT: Sole artifact path in the canonical Frictionless package.
FRICTIONLESS_PROFILE: Closed Frictionless Data Package profile identifier.
GENID_WELL_KNOWN_PATH: The well-known path (RFC 8615) under which skolem IRIs are minted, including both surrounding separators: a skolem IRI is {authority}{GENID_WELL_KNOWN_PATH}{encoded}.
GTS_EXTENSIONS: The extensions/ids that name the GTS transport container, on the same single-authority rule as PACK_EXTENSIONS: no other module spells "gts" as a format literal.
JSON_LD_SERIALIZE_OPTIONS_VERSION: Version of the closed JSON-LD serialization-options document.
MAX_TLV_BLOCK_LEN: Maximum canonical TLV block size in PURREMB v1.
MAX_TLV_DEPTH: Maximum nested TLV depth in PURREMB v1.
OKF_TERMS_PROFILE: Stable unified-projection profile name for caller-curated OKF bundles.
PACK_EXTENSIONS: The extensions/ids that name the native PurRDF pack container. The single authority for the pack literal — no other module in the workspace may spell "purrpck" or "pack" as a format literal; every consumer routes through classify_source.
PROJECTION_CODECS: Projection codecs: lossy targets that select a semantic subset of the source graph (decidable fragments, rule languages, foundational profiles).
PURREMB_DIRECTORY_ENTRY_LENGTH: Fixed PURREMB v1 directory-entry size.
PURREMB_FILE_ALIGNMENT: Required file-relative section alignment.
PURREMB_HEADER_LENGTH: Fixed PURREMB v1 header size.
PURREMB_MAGIC: PURREMB v1 file magic.
PURREMB_MAX_SECTION_COUNT: Maximum number of directory entries in v1.
PURREMB_TRAILER_LENGTH: Fixed PURREMB v1 trailer size.
PURREMB_TRAILER_MAGIC: PURREMB v1 trailer magic.
PURREMB_VERSION: PURREMB v1 format version.
RDFC_CALL_LIMIT: The fixed recursion/permutation call budget for the n-degree search. Generous for every non-adversarial dataset; exhaustion means a pathologically symmetric blank graph and is a hard panic! (no knob, no degraded fallback — .goals).
RESEARCH_OBJECT_CODECS: Versioned research-object codec names governed by the shared semantic pivot.
RESEARCH_ROLES: Every mandatory research-object role, in stable configuration order.
RESERVED_NAMESPACE: The IRI namespace the RDF 1.2 overlay lowers into, reserved by this profile.
RO_CRATE_ARTIFACT: Sole artifact path in the canonical RO-Crate package.
RO_CRATE_PREVIEW_ARTIFACT: Self-contained HTML5 preview path in an attached RO-Crate package.
RO_CRATE_PREVIEW_FILES_PREFIX: Reserved prefix for external preview support files.
RO_CRATE_PROFILE: Closed RO-Crate projection profile identifier.
RO_CRATE_ROLES: Every mandatory RO-Crate role in deterministic configuration order.
SECTION_CONTRACTS: Vector-family contracts section.
SECTION_CRITICAL: Required-section flag.
SECTION_DERIVED: Derived-accelerator flag.
SECTION_EXTENSION_MIN: First caller-extension section kind.
SECTION_EXTERNAL_BINDINGS: Exact external-artifact bindings section.
SECTION_INDEX_GUARDS: Opaque derived-index guard section.
SECTION_INDEX_PAYLOAD: Raw inline index-payload section kind.
SECTION_MATRICES: Stored-matrix and effective-projection records section.
SECTION_MATRIX_DATA: Raw authoritative matrix-data section kind.
SECTION_RELATIONS: Structural target relations section.
SECTION_SOURCE: Exact source-pack binding section.
SECTION_TARGETS: Canonical target table section.
SECTION_TARGET_SETS: Canonical target-set table section.
SECTION_TOKEN_SPANS: Family-scoped token-span section.
SSSOM_DEFAULT_VALIDATION_TYPES: The default check set sssom-py runs (validation_types=None), captured from sssom.validators.DEFAULT_VALIDATION_TYPES into the frozen golden. The native validator implements the two reachable-through-parse checks of this set (PrefixMapCompleteness, JsonSchema); StrictCurieFormat is unreachable because PurRDF never emits a pipe-bearing entity slot. Exposed so a consumer can report the parity surface it covers.
VOID_ROLES: Every mandatory VoID target role, in stable configuration order.

Traits§

CsvwRdfTableMapping: Caller-owned semantics for mapping an RDF backend into a CSVW table group.
DatasetMut: The write companion to DatasetView — the mutation surface a copy-on-write or backed-by-store dataset exposes (purrdf P5; backend contract C4).
DatasetView: A static, allocation-free read view over an RDF dataset (purrdf backend contract, C2/C3/C6). All methods are infallible for a frozen, validated dataset.
FallibleDatasetView: A DatasetView whose backing data can fail during lazy reads.
LpgProgressObserver: Fallible observer for deterministic LPG progress snapshots.
PageProvider: The demand-paging boundary between a PagedDataset and its frozen RdfDataset pages.
ProjectionArtifactSink: Transactional destination for path-delimited projection artifact chunks.
RdfDatasetVisitor: A receiver for the evented, ID-addressed output of a frozen RdfDataset.
RdfParserBackend: Parser ingress seam: drive RDF bytes into any event sink.
RdfSerializer: Serializer egress seam over the frozen IR.
SparqlEngine: SPARQL query/update seam. The dataset type is associated so an oxigraph-backed engine can operate on its store while a future native engine can operate on the IR/native query store.
TermFactory: Term interning seam: dataset-independent values enter a concrete term table.

Functions§

assert_ledger_complete: Panicking wrapper over check_ledger_complete: the set of codes ledger recorded MUST exactly match expected_codes.
assert_ledger_sound: Panicking wrapper over check_ledger_sound: every code ledger recorded MUST be a member of profile_for(from, to).
canonical_flat_nquads: The RDFC-1.0 canonical N-Quads document of dataset, flattened: the RDF 1.2 statement overlay (reifier bindings + annotations) is re-materialized to plain rdf:reifies / annotation triples BEFORE canonicalizing, with no overlay re-fold.
canonical_flat_nquads_with: canonical_flat_nquads with an explicit RDFC-1.0 hash algorithm (CanonHash::Sha384 selects the SHA-384 variant). Used by the W3C RDFC-1.0 conformance gate, whose test075 vector pins SHA-384.
canonical_relabel: Relabel every blank node of ds to its canonical c14n{n} label at BlankScope::DEFAULT, returning a NEW frozen dataset with all other terms, quads, reifiers, annotations, named-graph declarations, and quad source locations preserved.
canonical_tlv: Validates a canonical TLV block and returns an allocation-free iterator.
canonicalize: Canonicalize ds under profile CANON_PROFILE_ID (RDFC-1.0 with SHA-256, extended by the RDF 1.2 overlay).
canonicalize_with: Canonicalize ds under profile CANON_PROFILE_ID with an explicit hash algorithm (CanonHash::Sha384 is RDFC-1.0’s SHA-384 variant). See canonicalize.
check_admissible: Whether ds is admissible to canonicalization under profile CANON_PROFILE_ID — i.e. carries no IRI in RESERVED_NAMESPACE.
check_ledger_complete: Verify the set of codes ledger actually recorded exactly matches expected_codes — “complete” meaning every expected dropped construct is recorded (no silent loss) AND nothing outside expected_codes slipped in unnoticed (no undeclared drift). Order and duplicate occurrences in ledger are irrelevant; only the set of distinct codes is compared.
check_ledger_sound: Verify every code ledger actually recorded is a member of profile_for(from, to) — “sound” meaning nothing surprising reached the ledger. A code outside the declared profile is flagged by name: it is an undeclared, unintentional loss (a bug), never an accepted contract.
check_provenance: Validate the provenance sidecar against the dataset it describes.
classify: Resolve a media type or local format id to a NativeRdfFormat.
classify_source: Resolve a media type, format id, or (optionally dot-prefixed) file extension to a SourceFormat.
compile_schema: Compile an explicit ontology-aware schema request.
dataset_diff: A richer diff for test diagnostics: structural counts plus the isomorphism verdict.
dataset_from_bytes: Parse RDF bytes and freeze them into a validated RdfDataset via the native codec path.
dataset_from_quad_sources: Freeze several independently-parsed native RdfQuad streams into ONE validated RdfDataset, folding the RDF 1.2 statement layer, with blank nodes standardized apart per source.
dataset_from_quads: Freeze already-built native RdfQuads into a validated RdfDataset, folding the RDF 1.2 statement layer.
dataset_from_view: Reconstruct a concrete, frozen Arc<RdfDataset> from ANY DatasetView by re-interning every term BY VALUE into a fresh RdfDatasetBuilder.
datasets_isomorphic: IR-direct structural comparison. Returns true iff the two datasets are RDF-structurally isomorphic: the same quads (under a blank-node bijection), the same reifier bindings, and the same annotations. Oxigraph is NEVER consulted.
decode_detected: Detect and decode in one step, borrowing data unchanged when it is not wrapped.
decode_transport: Decode data under encoding, draining the decoder to completion.
derive_artifact_root: Derives the whole-artifact root from the root-zeroed header and directory.
derive_chunking_contract_id: Derives the chunking-contract id from the nested chunking-stage block.
derive_external_binding_id: Derives an external-artifact binding id.
derive_external_contract_digest: Derives the digest of a canonical external-artifact contract.
derive_family_contract_digest: Derives a digest from a canonical family-contract block.
derive_family_id: Derives the family id from its contract digest.
derive_index_guard_digest: Derives the digest of a canonical opaque-index guard.
derive_index_id: Derives an opaque derived-index id.
derive_jsonld_context: Derive a deterministic, vocabulary-neutral JSON-LD context from dataset IRI slots.
derive_matrix_content_digest: Derives the typed content digest of exact stored matrix bytes.
derive_matrix_id: Derives a stored-matrix id.
derive_projection_content_digest: Derives the typed content digest of an effective projection byte stream.
derive_projection_id: Derives an effective projection id.
derive_relation_role_digest: Derives a role digest for an extension relation.
derive_target_id: Derives the target id from its kind and identity digest.
derive_target_identity_digest: Derives a target identity digest from its kind and canonical block.
derive_target_set_id: Derives a target-set id from its strictly sorted target ids.
derive_vector_space_id: Derives one effective vector-space id.
describe: One-shot convenience: the SCBD of a single IRI subject in dataset.
deskolemize: Deskolemize dataset under the caller-supplied authority: return a NEW frozen dataset in which exactly the IRIs under {authority}/.well-known/genid/ are decoded back to the blank nodes (label, scope) they encode, in every position blanks may occupy. IRIs under any OTHER authority’s genid path are untouched. The exact inverse of skolemize under the same authority. As with skolemize, the non-serialized derived side tables (content_ids, predecessors/predecessor_chain) survive the rewrite (see the crate-private rebuild_dataset helper).
detect_transport: Detect the transport encoding wrapping data.
display_term: Render an RdfTerm in Turtle term syntax WITHOUT applying the blank-node label escape (full <iri>, _:bnode, literal, or the RDF 1.2 non-asserting triple term <<( <s> <p> <o> )>>).
emit_annotation: Emit a standalone annotation triple <reifier> <predicate> <object> ..
emit_quad: Emit a single quad as a Turtle statement line (<s> <p> <o> .).
emit_reifier: Emit a reifier binding as <reifier> rdf:reifies <<( s p o )>> ; <pred> <obj> ; … .
emit_resource: Emit a free-standing resource: <subject> a <type> ; <pred> <obj> ; … .
emit_term: Serialize an RdfTerm to its Turtle form (full <iri>, _:bnode, literal, or the RDF 1.2 non-asserting triple term <<( <s> <p> <o> )>>).
encode_external_bindings: Canonicalizes exact external bindings and encodes EXTERNAL_BINDINGS.
encode_family_contracts: Canonicalizes generation contracts and encodes the CONTRACTS section.
encode_index_guards: Canonicalizes derived indexes and encodes INDEX_GUARDS plus inline payload bodies in assigned instance order.
encode_relations: Canonicalizes structural relations and encodes the RELATIONS section.
encode_target_sets: Canonicalizes target sets and encodes the TARGET_SETS section.
encode_targets: Canonicalizes targets and encodes the TARGETS section.
encode_token_spans: Canonicalizes family-scoped spans and encodes the TOKEN_SPANS section.
escape_cypher_identifier: Escape an openCypher backtick-delimited identifier body.
escape_cypher_string: Escape an openCypher single-quoted string body.
escape_xml_attribute: Escape a double-quoted XML 1.0 attribute value.
escape_xml_text: Escape XML 1.0 character-data text.
flat_dataset_from_quad_sources: Freeze several independently-parsed flat owned-RdfQuad streams into ONE dataset WITHOUT folding the RDF 1.2 statement layer (every quad — including a rdf:reifies triple-term row — stays a plain quad), with blank nodes standardized apart per source.
flat_dataset_from_quads: Freeze a flat owned-RdfQuad stream into a dataset WITHOUT folding the RDF 1.2 statement layer (every quad — including a rdf:reifies triple-term row — stays a plain quad).
flat_rdf_quads_from_dataset: Flatten a frozen RdfDataset into the source-faithful flat RdfQuad stream, for consumers that fold over RdfQuad. Base quads first, then the re-materialized rdf:reifies reifier rows and the annotation rows. The IR fold + this un-fold are exact inverses.
fno_to_ntriples: Serialize a FnoCatalog’s typed model to N-Triples text (the rdflib-parseable form the Python side re-parses).
fno_to_quads: Build the typed model’s quads in the EXACT shape emit_fno / _emit_fnom produced — the same triple set, datatypes, and language tags.
gts_to_rdf_loss_ledger: The intentional losses incurred reading GTS → the RDF 1.2 dataset IR.
import_gts_events: The authoritative GTS ingestion path: folds GTS bytes into a GtsBundle, preserving per-segment blank-node scope (C2.a).
import_gts_graph: Consume a folded GTS Graph by value, MOVING owned term strings into the interner, and return the frozen GtsBundle.
lift_archive: Lift one strict bidirectional carrier archive into RDF 1.2.
lift_lpg: Lift a validated canonical LPG into a concrete RDF 1.2 dataset.
lift_okf_bundle: Lift a deterministic OKF Markdown bundle into any RDF 1.2 event sink.
lift_research_object: Lift one normalized research-object model into caller-vocabulary RDF 1.2.
loss_matrix_json: The enumerable loss registry as deterministic JSON: every (from, to) pair registered_pairs reports — the RDF↔GTS directions, every non-identity syntax/projection transcode pair, the shapes projection, and schema-language emitter profiles — rendered from registry_entries sorted by (from, to, code). Unlike a single LossLedger::contract, codes are NOT assumed unique here — the same code recurs for different (from, to) pairs.
lpg_to_rdf_loss_ledger: Closed canonical/native LPG→RDF 1.2 interpretation contract.
okf_to_rdf_loss_ledger: The closed loss contract for lifting an OKF Markdown bundle into an RDF 1.2 event stream.
pack_digest: Read a pack’s stored canonical-identity digest AFTER structural validation, without the (more expensive) independent recompute verify_pack performs.
pair_loss_ledger: Compute the static loss contract for a from → to transcoding pair.
parse_dataset: Parse RDF text bytes of media_type into a frozen RdfDataset.
parse_dataset_from_reader: Parse an RDF document out of a Read into a frozen RdfDataset.
parse_dataset_with: parse_dataset reporting everything the parse learned: the dataset, the opt-in source-position side table, and the base the document ended up under.
profile_for: The closed set of loss codes a from -> to conversion may drop, per the enumerable registry.
project_archive: Project a dataset view into one deterministic USTAR carrier archive.
project_archive_with_assets: Project RDF 1.2 and a bounded payload carrier into an attached RO-Crate archive.
project_construct_view: Evaluate a caller-supplied SPARQL CONSTRUCT over any static RDF 1.2 dataset view.
project_croissant: Project caller-vocabulary RDF 1.2 into canonical Croissant 1.1 JSON.
project_csvw: Apply a caller-owned RDF mapping and write its deterministic CSVW package.
project_csvw_exact: Project any RDF dataset view into the canonical exact CSVW profile.
project_csvw_terms: Project any RDF 1.2 dataset backend into caller-declared curated CSVW tables.
project_datacite: Project caller-vocabulary RDF 1.2 into deterministic DataCite 4.6 XML.
project_dcat: Project caller-vocabulary RDF 1.2 into canonical DCAT 3 JSON-LD.
project_dcat_rdf: Project caller-vocabulary RDF 1.2 into deterministic native DCAT RDF.
project_frictionless: Project caller-vocabulary RDF 1.2 into canonical Data Package v1 JSON.
project_lpg: Project any static RDF dataset view into the canonical LPG model.
project_lpg_artifacts_to_sink: Project one LPG profile directly into a transactional artifact sink.
project_lpg_csv: Project any RDF dataset view directly into the deterministic generic CSV package.
project_lpg_csv_to_sink: Project RDF directly into incrementally emitted generic LPG CSV artifacts.
project_lpg_cypher: Project any RDF dataset view directly into the deterministic openCypher package.
project_lpg_cypher_to_sink: Project RDF directly into incrementally emitted openCypher artifacts.
project_lpg_graphml: Project any RDF dataset view directly into deterministic GraphML 1.0.
project_lpg_graphml_to_sink: Project RDF directly into incrementally emitted GraphML artifacts.
project_lpg_with_progress: Project an RDF dataset view while reporting monotonic mapping progress.
project_neo4j_csv: Project any RDF dataset view directly into Neo4j Admin Import CSV artifacts.
project_neo4j_csv_to_sink: Project RDF directly into incrementally emitted Neo4j Admin Import artifacts.
project_obo_graphs: Project any static RDF dataset backend into OBO Graphs 0.3.2.
project_okf_terms: Project any RDF 1.2 dataset backend into a deterministic caller-curated OKF bundle.
project_research_object: Interpret one RDF 1.2 dataset view as the shared research-object model.
project_ro_crate: Project caller-vocabulary RDF 1.2 into canonical RO-Crate 1.3 JSON-LD.
project_ro_crate_with_assets: Project RDF 1.2 plus bounded payload artifacts into an attached RO-Crate 1.3.
project_skos: Project any static RDF dataset backend into a deterministic SKOS view.
project_void: Generate one deterministic, blank-free VoID dataset description.
rdf_gts_loss_matrix_json: The combined RDF↔GTS matrix as a single deterministic, sorted-by-code JSON array — the body of the generated generated/rdf-loss-matrix.json artifact.
rdf_to_gts_loss_ledger: The intentional losses incurred projecting the RDF 1.2 dataset IR → GTS.
rdf_to_lpg_loss_ledger: Closed RDF 1.2 dataset→canonical LPG semantic-lowering contract.
rdf_to_obo_graphs_loss_ledger: Closed RDF 1.2 dataset→OBO Graphs 0.3.2 view contract.
rdf_to_okf_loss_ledger: The closed loss contract for projecting an arbitrary RDF 1.2 dataset to an OKF Markdown bundle.
rdf_to_research_object_loss_ledger: Closed RDF 1.2 dataset→versioned research-object projection contract.
rdf_to_skos_loss_ledger: Closed RDF 1.2 dataset→SKOS concept-scheme view contract.
read_croissant: Read one strict Croissant 1.1 package and lift it into caller-vocabulary RDF.
read_csvw: Parse metadata and tables, validate them, and run the normative RDF mapping.
read_csvw_exact: Decode and strictly validate the canonical exact CSVW profile.
read_datacite: Read strict DataCite 4.6 XML and lift caller-vocabulary RDF 1.2.
read_dcat: Read strict DCAT 3 JSON-LD and lift caller-vocabulary RDF 1.2.
read_frictionless: Read strict Data Package v1 JSON and lift caller-vocabulary RDF 1.2.
read_lpg_csv: Decode the strict generic CSV profile into its canonical LPG model.
read_lpg_cypher: Read the complete closed openCypher grammar emitted by PurRDF.
read_lpg_graphml: Decode the strict GraphML 1.0 profile emitted by PurRDF.
read_neo4j_csv: Decode the strict emitted Neo4j Admin Import profile into canonical LPG.
read_ro_crate: Read a strict RO-Crate 1.3 package and lift caller-vocabulary RDF 1.2.
registered_pairs: Every (from, to) pair with a registered loss profile: the RDF↔GTS directions, graph/tabular/view profiles, every non-identity syntax/projection transcode pair, the shapes projection, and schema-language emitter profiles.
reopen_prevalidated: Structurally reopens the same immutable resident bytes under a prior proof.
require_compatible_vector_spaces: Rejects a comparison across distinct effective vector spaces.
research_object_to_rdf_loss_ledger: Closed versioned research-object→RDF 1.2 interpretation contract.
restore_pack: Open a succinct dataset pack and restore its complete RDF 1.2 value into a concrete, frozen Arc<RdfDataset>.
rule_iri: Mint the namespaced, percent-encoded rule IRI for a rule label.
serialize_dataset: Serialize a frozen RdfDataset to RDF text of media_type, honoring the SerializeGraph selection. Returns the serialized bytes.
serialize_dataset_to_format: Serialize the frozen IR to a concrete NativeRdfFormat, returning the bytes and the count of RDF-1.2 statement-layer rows dropped because the target format does not carry the star layer (the projection doctrine).
serialize_dataset_to_format_with_jsonld_options: Serialize through the generic format surface with explicit JSON-LD/YAML-LD configuration.
serialize_dataset_to_jsonld: Serialize the carrier dataset to a deterministic JSON-LD-star document.
serialize_dataset_to_jsonld_with_context: Serialize a dataset through an already compiled, reusable caller context.
serialize_dataset_to_jsonld_with_options: Serialize a carrier dataset under an explicitly selected JSON-LD mode.
serialize_dataset_to_yamlld: Serialize the carrier dataset to deterministic YAML-LD-star bytes.
serialize_dataset_to_yamlld_with_context: Serialize a dataset to deterministic YAML-LD through an already compiled, reusable caller context.
serialize_dataset_to_yamlld_with_options: Serialize a dataset to deterministic YAML-LD under an explicitly selected mode.
serialize_dataset_with: Serialize a frozen dataset under an explicit target format, document base, and policy — the one serialization seam in this crate.
serialize_dataset_with_jsonld_options: Serialize JSON-LD or YAML-LD through the generic media-type surface under an explicit configured mode.
serialize_rdf_description: Package an already-materialized RDF 1.2 description graph in any registered syntax.
skolemize: Skolemize dataset under the caller-supplied authority: return a NEW frozen dataset in which every blank node — in subject, object, and graph-name position, inside quoted-triple terms, as a reifier, in annotations, and in named-graph declarations — is replaced by the IRI {authority}/.well-known/genid/{encoded}, per the RDF 1.2 skolemization scheme. encoded is the injective, reversible segment encoding of the blank’s (label, scope) documented at module level, so deskolemize under the same authority reconstructs the original dataset exactly (labels AND scopes). All other terms, quads, reifiers, annotations, and quad source locations are preserved. The non-serialized derived side tables (content_ids, predecessors/predecessor_chain) survive the rewrite too (the crate-private rebuild_dataset helper implements the exact contract): content addressing re-derives from the output’s IRI bytes under dataset’s own ContentIdScheme, and the predecessor index resolves over the carried-forward annotation table.
sniff_transport: Detect the transport encoding wrapping a Read stream WITHOUT consuming it.
stable_identifier: Build a stable collision-resistant identifier from a caller-owned ASCII prefix and arbitrary key bytes.
strip_transport_suffix: The transport suffix name carries, and name with that suffix removed.
transcode_under_document_base: Transcode a document from one native syntax to another, re-emitting it under the base the SOURCE document itself declared.
transport_reader: Wrap reader in the decoder for encoding, or pass it through when encoding is None.
try_canonicalize: Canonicalize ds under profile CANON_PROFILE_ID, returning a typed CanonError instead of panicking.
try_canonicalize_with: Fallible, explicit-hash-algorithm form of try_canonicalize. See canonicalize_with for the panicking (trusted-caller) equivalent.
validate_absolute_iri: Validate a mandatory absolute IRI configuration field.
verify_embedding: Verifies every contained digest, identity, scalar, and logical projection.
verify_embedding_source: Verifies the exact attached pack and, optionally, its certified RDF identity.
verify_external_artifact: Checks exact bytes against one generic external-artifact binding.
verify_external_pack: Checks exact bytes and independently certifies a pack-backed external binding.
verify_pack: Open, structurally verify, and CERTIFY a pack: PackView::from_bytes first (magic/version/every section’s SHA-256/each submodule’s own structural validation), then independently reconstruct the dataset the pack claims to encode and recompute its purrdf-rdfc12 SHA-256 digest, then compare that recompute to the pack’s own stored rdfc_digest header field.
write_csvw: Write a normalized table group to canonical metadata and CSV resources.
write_lpg_csv: Encode a canonical LPG as deterministic generic CSV artifacts.
write_lpg_csv_to_sink: Encode generic LPG CSV artifacts incrementally into a transactional sink.
write_lpg_cypher: Encode a canonical LPG as a deterministic, injection-safe openCypher package.
write_lpg_cypher_to_sink: Encode canonical LPG artifacts incrementally into a transactional sink.
write_lpg_graphml: Encode a canonical LPG as deterministic GraphML 1.0 XML.
write_lpg_graphml_to_sink: Encode canonical GraphML artifacts incrementally into a transactional sink.
write_neo4j_csv: Encode a canonical LPG as deterministic Neo4j Admin Import CSV artifacts.
write_neo4j_csv_to_sink: Encode Neo4j Admin Import artifacts incrementally into a transactional sink.
write_okf_bundle: Project a frozen RDF 1.2 dataset through OkfWriter.

Type Aliases§

Bytes: Owned blob payload bytes. A thin alias so the by-reference doctrine reads clearly at call sites: only the kernel’s ContentStore ever owns a Bytes; everything else holds a ContentDigest.
CsvwAnnotations: Common JSON-LD annotations after inherited-property processing.
CsvwNaturalLanguage: Natural-language values keyed by a BCP47 language tag.
FastHasher: The workspace fixed-key ahash hasher builder. Non-cryptographic, no runtime RNG seeding — see the module docs for the determinism policy.
FastMap: A std::collections::HashMap keyed by the workspace FastHasher.
FastSet: A std::collections::HashSet hashed by the workspace FastHasher.
HandleKey: The key identifying the named graph a typed handle backs. An IRI string is the stable, dataset-independent name of the graph the handle projects.
IdSet: A FastSet of interned TermIds — the common id-membership set.
IdVec: A small-vector of interned TermIds, inline up to 4 ids.
SniffedStream: A stream whose leading magic-byte window has been read and prepended back, so the consumer still sees every byte of the original stream in order.

Crate purrdf

Crate purrdf Copy item path

§Example

§The document base

Re-exports§

Modules§

Macros§

Structs§

Enums§

Constants§

Traits§

Functions§

Type Aliases§

Crate purrdf