@littlebigbrain/client 0.11.1 → 0.13.0

package/dist/schema.d.ts

@@ -381,6 +381,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/graph/publication-status": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Automatic publication lifecycle and exact read watermarks */
+        get: operations["get_v1_graph_publication_status"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/graph/read-snapshot": {
         parameters: {
             query?: never;
@@ -432,6 +449,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/graph/schema-summary": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Compact observed RDF schema attached to the immutable F3 base */
+        get: operations["get_v1_graph_schema_summary"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/graph/summary": {
         parameters: {
             query?: never;
@@ -798,7 +832,7 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** Read the durable ontology-conformance report referenced by the published snapshot, including its validation watermark and ontology/shapes provenance */
+        /** Read the immutable branch-owned ontology-conformance sidecar selected by the F3 checksum and schema identity */
         get: operations["get_v1_ontology_conformance"];
         put?: never;
         post?: never;
@@ -817,7 +851,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Import a custom ontology and create the scoped graph head with it; fails if the graph already exists */
+        /** Define or additively evolve a graph ontology, or preview the exact result without mutation */
         post: operations["post_v1_ontology_define"];
         delete?: never;
         options?: never;
@@ -1325,8 +1359,25 @@ export interface components {
             /** @description Whether the relation is transitive (default false). */
             transitive?: boolean;
         };
+        /**
+         * @description Add direct parent classes to an existing entity type. All named classes
+         *     must already exist, or be declared earlier in the same request with
+         *     `add_entity_type`. Existing links are skipped, so the op is idempotent.
+         *     Removing a parent is not additive and requires an explicit migration.
+         */
+        AddSuperTypesOp: {
+            /** @description Entity type whose direct parents should grow. */
+            entity_type: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            op: "add_super_types";
+            /** @description Direct parent entity-type names to add. */
+            super_types: string[];
+        };
         /** @description Governed proposal operation restricted to additive ontology changes. */
-        AdditiveOntologyEvolveOp: components["schemas"]["WidenRelationOp"] | components["schemas"]["AddEntityTypeOp"] | components["schemas"]["AddRelationOp"] | components["schemas"]["AddPropertyOp"];
+        AdditiveOntologyEvolveOp: components["schemas"]["WidenRelationOp"] | components["schemas"]["AddEntityTypeOp"] | components["schemas"]["AddSuperTypesOp"] | components["schemas"]["AddRelationOp"];
         /** @description Additive-only ontology proposal helper for structured-output systems. */
         AdditiveOntologyEvolveRequest: {
             ops: components["schemas"]["AdditiveOntologyEvolveOp"][];
@@ -3322,45 +3373,6 @@ export interface components {
          * @enum {string}
          */
         IndexVisibilityFamily: "base" | "rdf" | "bm25" | "ann";
-        /**
-         * @description A single inference rule (SHACL-AF `sh:TripleRule` shape): a BGP `body` (the
-         *     condition / `WHERE`) and a `head` triple template instantiated once per
-         *     binding. Every variable used in `head` must be bound by `body`.
-         */
-        InferenceRule: {
-            /**
-             * @description The rule condition: a basic graph pattern over current edges (asserted +
-             *     already-derived), joined on shared variables.
-             */
-            body?: components["schemas"]["AnalyticTriplePattern"][];
-            /**
-             * @description Negation/existence filters folded over the `body` solutions, in order.
-             *     Only `exists` (semijoin — keep body rows that have a compatible match) and
-             *     `not_exists` (antijoin — keep body rows that have none) are supported in a
-             *     rule; `union`/`optional`/`minus` are rejected. A `not_exists` over a
-             *     relation produced by another rule's head places this rule in a strictly
-             *     higher evaluation stratum (so the negated relation is fully derived first);
-             *     a negation cycle is rejected. This is what lets a rule express universal
-             *     conditions like "phase complete when no deliverable is incomplete". A
-             *     filter pattern may introduce its own local variables and may reference
-             *     `body` variables to correlate, but it never binds a `head` variable.
-             */
-            combinators?: components["schemas"]["AnalyticCombinator"][];
-            /**
-             * @description The triple template derived once per `body` binding. `subject`/`object`
-             *     are variables bound by `body` (or fixed entities); `predicate` is a
-             *     relation name.
-             */
-            head: components["schemas"]["AnalyticTriplePattern"];
-            name: string;
-            /**
-             * Format: int64
-             * @description SHACL `sh:order`. Rules run low-to-high; a determinism hint for the
-             *     positive (monotone) rules supported today, where the least fixpoint is
-             *     order-independent.
-             */
-            order?: number;
-        };
         LbbErrorBody: {
             /** @example missing_idempotency_key */
             code: string;
@@ -3797,6 +3809,12 @@ export interface components {
          *     difference is refused with a typed error naming the route that applies it.
          */
         OntologyDefineRequest: {
+            /**
+             * @description Preview the exact definition without creating a graph, writing an
+             *     ontology object, or changing the graph head. Equivalent to the
+             *     `?dry_run=true` query parameter; either signal enables preview mode.
+             */
+            dry_run?: boolean;
             /** @description Import format hint. `auto` (the default) sniffs the content. */
             format?: string | null;
             /**
@@ -3812,29 +3830,28 @@ export interface components {
         };
         OntologyDefineResponse: {
             /**
-             * @description True when this call wrote a new ontology version, either by creating the
-             *     graph or by applying an additive difference. False when the proposed
-             *     ontology already matched the active one, which is what makes re-running
-             *     the same bootstrap request a no-op.
+             * @description True when this call wrote a new ontology version, or when a dry run
+             *     predicts that it would. False when the proposed ontology already matched
+             *     the active one, which is what makes re-running the same bootstrap request
+             *     a no-op.
              *
-             *     This tracks what was written, so it never reports `false` for a call
-             *     that changed the ontology: a widened relation domain or range and a new
-             *     property field both set it, even though neither appears in the
-             *     class-and-relation schema diff.
+             *     A widened relation domain or range and a new property field both set it,
+             *     even though neither appears in the class-and-relation schema diff.
              */
             changed?: boolean;
             /**
-             * @description The additive changes this call applied to an existing graph's ontology.
-             *     Empty when the graph was created and when nothing changed.
+             * @description The additive changes this call applied, or would apply during a dry run,
+             *     to an existing graph's ontology. Empty on create and no-op.
              */
             changes?: components["schemas"]["SchemaDiffEntry"][];
+            /** @description True when this response is a preview and no durable state changed. */
+            dry_run?: boolean;
             entity_types: components["schemas"]["OntologyTermView"][];
             format: string;
             graph: components["schemas"]["GraphKey"];
             /**
-             * @description True when this call created the graph head. False when the graph already
-             *     existed, whether the ontology then changed or not. This is the `created`
-             *     signal for the define route.
+             * @description True when this call created the graph head, or when a dry run predicts
+             *     that the real definition would create it.
              */
             graph_created: boolean;
             merged_default: boolean;
@@ -3879,6 +3896,8 @@ export interface components {
         OntologyDraftStatus: "draft" | "validated" | "promoted" | "rejected";
         /** @description The full definition of one entity type (class) in the active ontology. */
         OntologyEntityTypeView: {
+            /** @description Canonical query IRI minted by Little Big Brain for this class identity. */
+            iri?: string;
             name: string;
             properties: components["schemas"]["OntologyPropertyView"][];
             /** Format: int64 */
@@ -3887,6 +3906,17 @@ export interface components {
             resolvable: boolean;
             /** Format: int64 */
             since_version: number;
+            /**
+             * @description Frozen class identity used by commits and the RDF projection. This is
+             *     unique even when imported vocabularies reuse the same local name.
+             */
+            stable_id?: string;
+            /**
+             * @description Direct parent classes (`rdfs:subClassOf`), named by their frozen
+             *     `stable_id`s. Clients can build the full class lattice without a SPARQL
+             *     scan or a second ontology lookup.
+             */
+            super_types?: string[];
         };
         OntologyEvidenceSample: {
             /** @description Stable connector/source reference; sample content is never used as identity. */
@@ -3905,7 +3935,7 @@ export interface components {
          *     the supported "ontology evolution" path; identity-breaking changes (removals,
          *     narrowing) still require an explicit expand→migrate→contract plan.
          */
-        OntologyEvolveOp: components["schemas"]["WidenRelationOp"] | components["schemas"]["AddEntityTypeOp"] | components["schemas"]["AddRelationOp"] | components["schemas"]["AddPropertyOp"] | components["schemas"]["SetPropertyConstraintOp"] | components["schemas"]["RenameEntityTypeOp"] | components["schemas"]["RenameRelationOp"] | components["schemas"]["SetRelationInverseOp"] | components["schemas"]["SetRelationCardinalityOp"] | components["schemas"]["NarrowRelationOp"] | components["schemas"]["RemoveEntityTypeOp"] | components["schemas"]["RemoveRelationOp"];
+        OntologyEvolveOp: components["schemas"]["WidenRelationOp"] | components["schemas"]["AddEntityTypeOp"] | components["schemas"]["AddSuperTypesOp"] | components["schemas"]["AddRelationOp"] | components["schemas"]["AddPropertyOp"] | components["schemas"]["SetPropertyConstraintOp"] | components["schemas"]["RenameEntityTypeOp"] | components["schemas"]["RenameRelationOp"] | components["schemas"]["SetRelationInverseOp"] | components["schemas"]["SetRelationCardinalityOp"] | components["schemas"]["NarrowRelationOp"] | components["schemas"]["RemoveEntityTypeOp"] | components["schemas"]["RemoveRelationOp"];
         /**
          * @description Apply a list of additive ontology changes in order, writing a new ontology
          *     version when anything actually changes. Ops are applied against the
@@ -4383,6 +4413,42 @@ export interface components {
             /** @description Members of an `i64_set` field; canonicalized like `keyword_set`. */
             i64_set: number[];
         };
+        PublicationRetryGuidance: {
+            eventual_read_available: boolean;
+            message: string;
+            /** Format: int64 */
+            retry_after_ms: number;
+        };
+        /**
+         * @description Server-managed publication lifecycle for one graph epoch.
+         * @enum {string}
+         */
+        PublicationState: "current" | "queued" | "compacting" | "building" | "publishing" | "blocked";
+        /**
+         * @description One bounded status document for automatic exact-generation publication.
+         *     It is available before the first generation publishes, unlike
+         *     [`PublishedReadStatusResponse`], so SDKs can wait without probing SPARQL.
+         */
+        PublicationStatusResponse: {
+            current_stage?: string | null;
+            /** Format: int64 */
+            epoch: number;
+            /** Format: int64 */
+            head_generation: number;
+            head_seq: components["schemas"]["CommitSeq"];
+            /** Format: int64 */
+            lag_commits: number;
+            /** Format: int64 */
+            last_progress_at_micros: number;
+            /** Format: int64 */
+            published_generation?: number | null;
+            published_seq: components["schemas"]["CommitSeq"];
+            retry: components["schemas"]["PublicationRetryGuidance"];
+            state: components["schemas"]["PublicationState"];
+            /** Format: int64 */
+            target_head_generation: number;
+            target_seq: components["schemas"]["CommitSeq"];
+        };
         /**
          * @description Whether an import's deterministic published-generation job was newly
          *     queued or coalesced with equivalent pending work.
@@ -4506,6 +4572,52 @@ export interface components {
              */
             rerank_raw_bytes_fetched?: number;
         };
+        /**
+         * @description The RDF node kind of a bounded observed-schema statement object.
+         * @enum {string}
+         */
+        RdfSchemaObjectKind: "iri" | "blank_node" | "literal";
+        /** @description One OWL/RDFS vocabulary or annotation statement retained for schema UIs. */
+        RdfSchemaStatement: {
+            object: string;
+            object_kind: components["schemas"]["RdfSchemaObjectKind"];
+            predicate: string;
+            subject: string;
+        };
+        /**
+         * @description Compact, immutable observed-schema artifact attached to one exact F3 base.
+         *
+         *     This is the overview/read-model surface for Explorer and Ontology. It is
+         *     produced by maintenance while publishing F3 and is therefore cheap to read:
+         *     no request-time graph scan or base-plus-delta assembly is required.
+         */
+        RdfSchemaSummaryResponse: {
+            /**
+             * @description Per-predicate totals of literal-valued statements, the data-property
+             *     sibling of `resource_predicate_counts`. `None` when the stored summary
+             *     artifact predates this field; the next full summary rebuild fills it.
+             */
+            literal_predicate_counts?: components["schemas"]["RdfSchemaTermCount"][] | null;
+            /** Format: int64 */
+            ontology_version: number;
+            resource_predicate_counts: components["schemas"]["RdfSchemaTermCount"][];
+            snapshot: components["schemas"]["SnapshotView"];
+            statements: components["schemas"]["RdfSchemaStatement"][];
+            truncated: boolean;
+            type_counts: components["schemas"]["RdfSchemaTermCount"][];
+        };
+        /**
+         * @description One exact RDF term count in the compact observed-schema summary.
+         *
+         *     `term` is the complete IRI rather than a display-local name. This keeps
+         *     foreign vocabularies unambiguous; clients may choose their own prefix or
+         *     local-name presentation.
+         */
+        RdfSchemaTermCount: {
+            /** Format: int64 */
+            count: number;
+            term: string;
+        };
         /**
          * @description A page-region provenance anchor on a fact's evidence (region provenance
          *     §4.1/§6.4(b) BYO import): where the evidence appears in the source
@@ -4778,6 +4890,11 @@ export interface components {
         };
         SchemaAuditResult: {
             component: string;
+            /**
+             * @description Nested results explaining a composite violation (`sh:detail`), e.g.
+             *     which constraint inside a `sh:node` shape the value node failed.
+             */
+            details?: components["schemas"]["SchemaAuditResult"][];
             focus_node: string;
             message?: string | null;
             result_path?: string | null;
@@ -4825,6 +4942,8 @@ export interface components {
         /** @enum {string} */
         SchemaChangeKind: "additive" | "restrictive" | "identity_breaking";
         SchemaClassView: {
+            /** @description Canonical query IRI minted by Little Big Brain for this class identity. */
+            iri?: string;
             name: string;
             property_count: number;
             /** Format: int64 */
@@ -4832,6 +4951,8 @@ export interface components {
             /** Format: int64 */
             since_version: number;
             stable_id: string;
+            /** @description Direct parent classes (`rdfs:subClassOf`), named by `stable_id`. */
+            super_types?: string[];
         };
         /** @enum {string} */
         SchemaCompatibilityVerdict: "compatible" | "restrictive" | "migration_required";
@@ -5582,247 +5703,6 @@ export interface components {
             op: "set_relation_inverse";
             relation: string;
         };
-        /**
-         * @description Which constraint failed (SHACL `sourceConstraintComponent`).
-         * @enum {string}
-         */
-        ShaclConstraintComponent: "min_count" | "max_count" | "class" | "has_value" | "unique" | "datatype" | "min_inclusive" | "max_inclusive" | "min_exclusive" | "max_exclusive" | "min_length" | "max_length" | "in" | "pattern" | "and" | "or" | "not" | "xone" | "closed";
-        /**
-         * @description SHACL `sh:datatype` family, matched against a stored [`PropertyValue`] kind.
-         *     `decimal` accepts any numeric (integer or float); the rest are exact.
-         * @enum {string}
-         */
-        ShaclDatatype: "boolean" | "integer" | "decimal" | "string" | "date_time";
-        /**
-         * @description SHACL logical shape combinators over [`ShaclShapeConstraints`] operands, all
-         *     applied to the same focus node. Empty lists impose no constraint.
-         */
-        ShaclLogical: {
-            /** @description `sh:and`: the node must conform to **every** operand. */
-            and?: components["schemas"]["ShaclShapeConstraints"][];
-            /** @description `sh:not`: the node must conform to **none** of these operands. */
-            not?: components["schemas"]["ShaclShapeConstraints"][];
-            /** @description `sh:or`: the node must conform to **at least one** operand. */
-            or?: components["schemas"]["ShaclShapeConstraints"][];
-            /** @description `sh:xone`: the node must conform to **exactly one** operand. */
-            xone?: components["schemas"]["ShaclShapeConstraints"][];
-        };
-        /** @enum {string} */
-        ShaclMode: "select" | "validate";
-        ShaclNodeShape: {
-            /**
-             * @description `sh:closed`: when true, a focus node may carry **only** the outgoing
-             *     relations and literal fields named by this shape's property `path`s (plus
-             *     `ignored_properties`). Any undeclared one emits a `closed` violation.
-             *     `validate` mode only.
-             */
-            closed?: boolean;
-            /**
-             * @description `sh:deactivated`: when true the entire shape is skipped — no focus nodes,
-             *     no matches, no violations.
-             */
-            deactivated?: boolean;
-            /** @description Paths exempt from the `closed` check (SHACL `sh:ignoredProperties`). */
-            ignored_properties?: string[];
-            logical?: null | components["schemas"]["ShaclLogical"];
-            name?: string | null;
-            properties?: components["schemas"]["ShaclPropertyShape"][];
-            target_class?: string | null;
-            target_node?: null | components["schemas"]["EntitySelector"];
-            /**
-             * @description `sh:targetObjectsOf`: focus on every entity that is the **object**
-             *     (destination) of at least one relation of this name.
-             */
-            target_objects_of?: string | null;
-            /**
-             * @description `sh:targetSubjectsOf`: focus on every entity that is the **subject**
-             *     (source) of at least one relation of this name.
-             */
-            target_subjects_of?: string | null;
-            /**
-             * @description Cross-focus-node uniqueness constraints: the value reached at each
-             *     `path` must be held by at most one focus node of this shape. Only
-             *     evaluated in `validate` mode (uniqueness is an aggregate over the
-             *     focus set, which the per-node property constraints cannot express).
-             */
-            unique?: components["schemas"]["ShaclUnique"][];
-        };
-        /**
-         * @description A SHACL property path expression, evaluated by the bounded RDF path engine from
-         *     the focus node to a set of value-node entities. Mirrors SHACL's path grammar:
-         *     a single predicate, an inverse, a sequence, an alternative, and the
-         *     `*`/`+`/`?` closures.
-         */
-        ShaclPath: {
-            /** @description A single relation, followed forward (focus -> value). */
-            predicate: string;
-        } | {
-            /** @description Follow the inner path backwards. */
-            inverse: components["schemas"]["ShaclPath"];
-        } | {
-            /** @description Follow each sub-path in order (`p1 / p2 / …`). */
-            sequence: components["schemas"]["ShaclPath"][];
-        } | {
-            /** @description The union of the sub-paths (`p1 | p2 | …`). */
-            alternative: components["schemas"]["ShaclPath"][];
-        } | {
-            /** @description Reflexive transitive closure (`p*`), bounded. */
-            zero_or_more: components["schemas"]["ShaclPath"];
-        } | {
-            /** @description Transitive closure (`p+`), bounded. */
-            one_or_more: components["schemas"]["ShaclPath"];
-        } | {
-            /** @description Zero or one step (`p?`). */
-            zero_or_one: components["schemas"]["ShaclPath"];
-        };
-        /** @enum {string} */
-        ShaclPathDirection: "out" | "in" | "both";
-        ShaclPropertyShape: {
-            bind?: string | null;
-            datatype?: null | components["schemas"]["ShaclDatatype"];
-            /** @description `sh:deactivated`: when true this property constraint is skipped. */
-            deactivated?: boolean;
-            direction?: components["schemas"]["ShaclPathDirection"];
-            /**
-             * @description `sh:flags` for `pattern`: any of `i` (case-insensitive), `s` (dot matches
-             *     newline), `m` (multi-line), `x` (extended/ignore-whitespace).
-             */
-            flags?: string | null;
-            has_value?: null | components["schemas"]["EntitySelector"];
-            /**
-             * @description Enumerated allowed values (`sh:in`). On a literal (field) path each value
-             *     must equal one of these under typed comparison; on a relation path the
-             *     value entity must be one of the listed `Entity` selectors.
-             */
-            in?: components["schemas"]["SparqlValue"][] | null;
-            max_count?: number | null;
-            max_exclusive?: null | components["schemas"]["SparqlValue"];
-            max_inclusive?: null | components["schemas"]["SparqlValue"];
-            max_length?: number | null;
-            /**
-             * @description Author-set message overriding the engine-generated one (SHACL
-             *     `sh:message`). Applies to every violation of this property shape.
-             */
-            message?: string | null;
-            min_count?: number | null;
-            min_exclusive?: null | components["schemas"]["SparqlValue"];
-            min_inclusive?: null | components["schemas"]["SparqlValue"];
-            /** @description String length bounds (character count); apply to `keyword`/`text` values. */
-            min_length?: number | null;
-            optional?: boolean;
-            path: string;
-            path_expr?: null | components["schemas"]["ShaclPath"];
-            /**
-             * @description `sh:pattern`: a regular expression the string value must match (applies to
-             *     `keyword`/`text` values on a literal path).
-             */
-            pattern?: string | null;
-            severity?: null | components["schemas"]["ShaclSeverity"];
-            value_class?: string | null;
-        };
-        ShaclQueryExplain: {
-            focus_nodes_evaluated: number;
-            property_shapes_evaluated: number;
-            /** @description Matches in `select` mode; violations in `validate` mode. */
-            result_count: number;
-            shapes_evaluated: number;
-        };
-        ShaclQueryRequest: {
-            /**
-             * Format: int64
-             * @description Snapshot pin (transaction-time ceiling): shapes evaluate over the graph
-             *     as of this commit sequence, hiding later events. Omitted means head.
-             */
-            as_of_commit_seq?: number | null;
-            as_of_valid_time?: string | null;
-            explain: boolean;
-            /**
-             * @description Run `rules` and include the derived edges in evaluation. Default `false`,
-             *     so SHACL is **asserted-only** unless explicitly opted in — a rule can't
-             *     silently mask a real data-quality violation.
-             */
-            include_derived?: boolean;
-            /**
-             * @description `select` (the default) returns the focus nodes that match each shape.
-             *     `validate` instead returns a conformance report listing the focus nodes
-             *     that *violate* the shapes' constraints. Validation is detection, not
-             *     enforcement: it surfaces duplicates/violations that already exist but
-             *     blocks no write.
-             */
-            mode?: components["schemas"]["ShaclMode"];
-            /**
-             * @description Inference rules whose derived edges are folded into the snapshot the
-             *     shapes evaluate over, **only** when `include_derived` is set. Lets a shape
-             *     validate (or select against) inferred facts as well as asserted ones.
-             */
-            rules?: components["schemas"]["InferenceRule"][];
-            shapes: components["schemas"]["ShaclNodeShape"][];
-            top_k: number;
-        };
-        ShaclQueryResponse: {
-            explain?: null | components["schemas"]["ShaclQueryExplain"];
-            report?: null | components["schemas"]["ShaclValidationReport"];
-            results: components["schemas"]["ShaclQueryResult"][];
-            snapshot: components["schemas"]["SnapshotView"];
-        };
-        ShaclQueryResult: {
-            assertions: components["schemas"]["TripletView"][];
-            bindings: {
-                [key: string]: components["schemas"]["EntityView"][];
-            };
-            focus: components["schemas"]["EntityView"];
-            shape?: string | null;
-        };
-        /** @enum {string} */
-        ShaclSeverity: "violation" | "warning" | "info";
-        /**
-         * @description A reusable bundle of constraints applied to a focus node — the operand of a
-         *     logical combinator. Carries property constraints and (recursively) its own
-         *     nested logical combinators, but no target (operands share the parent shape's
-         *     focus node).
-         */
-        ShaclShapeConstraints: {
-            logical?: null | components["schemas"]["ShaclLogical"];
-            properties?: components["schemas"]["ShaclPropertyShape"][];
-        };
-        ShaclUnique: {
-            direction?: components["schemas"]["ShaclPathDirection"];
-            /**
-             * @description Optional message attached to each uniqueness violation; a default is
-             *     generated when absent.
-             */
-            message?: string | null;
-            /** @description Relation whose reached value identifies the focus node (e.g. `HAS_EMAIL`). */
-            path: string;
-        };
-        /**
-         * @description `validate`-mode conformance report. Mirrors the shape of a SHACL
-         *     `ValidationReport`: `conforms` is true iff `results` is empty.
-         */
-        ShaclValidationReport: {
-            conforms: boolean;
-            results: components["schemas"]["ShaclViolation"][];
-        };
-        /** @description A single conformance failure, mirroring a SHACL `ValidationResult`. */
-        ShaclViolation: {
-            component: components["schemas"]["ShaclConstraintComponent"];
-            /** @description The focus node that violated a constraint (SHACL `focusNode`). */
-            focus: components["schemas"]["EntityView"];
-            message: string;
-            /**
-             * @description Relation path the constraint applies to; absent for node-level
-             *     constraints (SHACL `resultPath`).
-             */
-            path?: string | null;
-            severity: components["schemas"]["ShaclSeverity"];
-            shape?: string | null;
-            /**
-             * @description Offending or related value nodes: wrong-class values for `class`, the
-             *     required target for `has_value`, or the other focus nodes a `unique`
-             *     collision is shared with.
-             */
-            value?: components["schemas"]["EntityView"][];
-        };
         ShadowArmResult: {
             /**
              * Format: float
@@ -6047,11 +5927,13 @@ export interface components {
          */
         SparqlCompareOp: "eq" | "ne" | "lt" | "le" | "gt" | "ge";
         /**
-         * @description RDFS entailment regime applied when projecting the graph for a conformant
-         *     SPARQL query. Controls whether a class term matches subtype instances.
+         * @description Entailment regime applied to a conformant SPARQL query. The regime is
+         *     evaluated at query time as a closure-driven pattern rewrite over the
+         *     dataset's asserted schema triples; the published dataset itself stays
+         *     asserted-only.
          * @enum {string}
          */
-        SparqlEntailment: "subclass" | "none";
+        SparqlEntailment: "owl" | "rdfs" | "subclass" | "none";
         /**
          * @description A FILTER over a solution: a comparison, or a boolean composition of filters.
          *     A comparison whose operands are unbound, incomparable, or a type mismatch is
@@ -6247,11 +6129,10 @@ export interface components {
             /** @description WHERE: the conjunctive basic graph pattern (shares the analytic engine). */
             patterns: components["schemas"]["AnalyticTriplePattern"][];
             /**
-             * @description Reason over the graph's stored inference rules so a pattern matches
-             *     asserted **and** derived edges in one shot. Off by default
-             *     (asserted-only). Public serving requires a compatible reasoned
-             *     projection in the pinned published generation and fails closed when it
-             *     is absent; it never forces an overlay reduce.
+             * @description Not available on the published SPARQL surface: a branch's stored
+             *     inference rules already run at publish time, folding derived facts into
+             *     the asserted dataset every query reads. Requesting `reason: true`
+             *     returns a typed, non-retryable error.
              */
             reason?: boolean;
             /**
@@ -6312,10 +6193,13 @@ export interface components {
          *     RDF graph, not a results table).
          */
         SparqlTextRequest: {
+            as_of_commit_seq?: null | components["schemas"]["CommitSeq"];
             /**
-             * @description RDFS entailment regime. `None` (default) reads the asserted published
-             *     projection. `Subclass` requires a compatible reasoned projection and
-             *     fails closed while one is unavailable.
+             * @description Entailment regime. `None` (default) matches asserted triples only.
+             *     `Rdfs` applies the practical RDFS core at query time, `Subclass` the
+             *     class-only subset, and `Owl` the OWL profile on top of `Rdfs`. All
+             *     derive the closure from the pinned generation's asserted schema
+             *     triples.
              */
             entailment?: components["schemas"]["SparqlEntailment"];
             /**
@@ -6328,12 +6212,10 @@ export interface components {
             /** @description The SPARQL query text (SELECT or ASK). */
             query: string;
             /**
-             * @description Reason over the branch's stored inference rules: project the rule-derived
-             *     facts into the dataset the conformant engine runs over, so a query reasons
-             *     over asserted **and** derived edges. Off by default; a no-op when the branch
-             *     has no stored rules. Combine with `entailment: subclass` for full
-             *     reasoning—rule-derived facts plus `rdfs:subClassOf` type closure—once
-             *     maintenance publishes a compatible reasoned projection.
+             * @description Not available on the published SPARQL surface: a branch's stored
+             *     inference rules already run at publish time, folding derived facts into
+             *     the asserted dataset every query reads. Requesting `reason: true`
+             *     returns a typed, non-retryable error.
              */
             reason?: boolean;
         };
@@ -10348,7 +10230,7 @@ export interface operations {
                 blank_node_scope?: string;
                 /** @description Entity type name for imported RDF resources (default Resource) */
                 resource_type?: string;
-                /** @description Set false to defer the published-generation enqueue; send build=false on every chunk except the last of a chunked bulk stream. Default true. */
+                /** @description Set false on intermediate chunks to defer eager publication. Each request still atomically commits a compacted truth segment and exact per-commit F3 delta; graph reconstruction, SHACL, and complete F3 construction run off-path. The server advances one coalesced safety fence when the deferred delta tail reaches 8 entries or 32 MiB, so a large stream cannot wedge itself. Omit build=false on the final chunk to advance the final fence. Default true. */
                 build?: string;
             };
             header?: {
@@ -10617,6 +10499,142 @@ export interface operations {
             };
         };
     };
+    get_v1_graph_publication_status: {
+        parameters: {
+            query?: {
+                /** @description Graph name (default `main`) */
+                graph?: string;
+                /** @description Branch name (default `main`) */
+                branch?: string;
+            };
+            header?: {
+                /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */
+                "Lbb-Version"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicationStatusResponse"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+        };
+    };
     get_v1_graph_read_snapshot: {
         parameters: {
             query?: {
@@ -11041,6 +11059,142 @@ export interface operations {
             };
         };
     };
+    get_v1_graph_schema_summary: {
+        parameters: {
+            query?: {
+                /** @description Graph name (default `main`) */
+                graph?: string;
+                /** @description Branch name (default `main`) */
+                branch?: string;
+            };
+            header?: {
+                /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */
+                "Lbb-Version"?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RdfSchemaSummaryResponse"];
+                };
+            };
+            /** @description Bad request */
+            400: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Not found */
+            404: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Conflict */
+            409: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+            /** @description Service unavailable */
+            503: {
+                headers: {
+                    /** @description API contract version used for the response */
+                    "Lbb-Version"?: string;
+                    /** @description Request correlation id */
+                    "X-Request-Id"?: string;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LbbErrorEnvelope"];
+                };
+            };
+        };
+    };
     get_v1_graph_summary: {
         parameters: {
             query?: {
@@ -14268,7 +14422,7 @@ export interface operations {
                 graph?: string;
                 /** @description Branch name (default `main`) */
                 branch?: string;
-                /** @description eventual (default) serves the referenced durable report; strong requires validation at current head with current ontology/shapes */
+                /** @description eventual (default) serves the selected base sidecar; strong requires an exact-head sidecar with current ontology/shapes */
                 consistency?: string;
                 /** @description Maximum returned result rows; result_count remains exact */
                 limit?: string;
@@ -14408,6 +14562,8 @@ export interface operations {
                 graph?: string;
                 /** @description Branch name (default `main`) */
                 branch?: string;
+                /** @description Validate and return the exact predicted definition without creating a graph, writing an ontology object, or changing the graph head */
+                dry_run?: string;
             };
             header?: {
                 /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */