@littlebigbrain/client 0.13.0 → 0.13.1

package/dist/client.d.ts

@@ -361,14 +361,18 @@ export declare class LbbClient {
         asOf?: string;
     }): Promise<Schemas["EntityMetadataResponse"]>;
     /**
-     * Entity detail: metadata, attributes, current state, edge history, and
-     * observations. Pass `asOf` / `asOfCommitSeq` to reproduce the node as of a
-     * past instant / commit (the state, edges, and history are pinned to it).
+     * Read projected attributes and current relationships from one RDF snapshot.
+     * Inspect `unavailable_sections` before interpreting legacy provenance arrays.
+     * Use strong consistency for read-after-write, or a retained commit sequence.
      */
     entityDetail(opts: {
         id?: string;
         type?: string;
         name?: string;
+        key?: string;
+        consistency?: "strong" | "eventual";
+        edges?: number;
+        /** @deprecated Valid-time reads are unsupported; use asOfCommitSeq. */
         asOf?: string;
         asOfCommitSeq?: number;
     }): Promise<Schemas["EntityDetailResponse"]>;

package/dist/client.js

@@ -900,9 +900,9 @@ export class LbbClient {
         });
     }
     /**
-     * Entity detail: metadata, attributes, current state, edge history, and
-     * observations. Pass `asOf` / `asOfCommitSeq` to reproduce the node as of a
-     * past instant / commit (the state, edges, and history are pinned to it).
+     * Read projected attributes and current relationships from one RDF snapshot.
+     * Inspect `unavailable_sections` before interpreting legacy provenance arrays.
+     * Use strong consistency for read-after-write, or a retained commit sequence.
      */
     entityDetail(opts) {
         return this.request("GET", "/v1/graph/entity", {
@@ -910,6 +910,9 @@ export class LbbClient {
                 id: opts.id,
                 type: opts.type,
                 name: opts.name,
+                key: opts.key,
+                consistency: opts.consistency,
+                edges: opts.edges,
                 as_of: opts.asOf,
                 as_of_commit_seq: opts.asOfCommitSeq,
             },

package/dist/namespaces.d.ts

@@ -77,11 +77,7 @@ export declare class EntityNamespace {
         name?: string;
         asOf?: string;
     }): Promise<Schemas["EntityMetadataResponse"]>;
-    detail(opts: {
-        id?: string;
-        type?: string;
-        name?: string;
-    }): Promise<Schemas["EntityDetailResponse"]>;
+    detail(opts: Parameters<LbbClient["entityDetail"]>[0]): Promise<Schemas["EntityDetailResponse"]>;
     /**
      * Filter entities already bound by relation patterns using typed attributes,
      * without writing RDF property IRIs by hand. This is a convenience wrapper over
@@ -97,7 +93,9 @@ export declare class SchemaNamespace {
     /** Read active metadata without running request-time validation. */
     view(opts?: CallOptions): Promise<Schemas["SchemaBundleView"]>;
     /** Atomically publish a bundle; conformance is produced asynchronously. */
-    publish(body: Schemas["SchemaPublishRequest"], opts?: CallOptions): Promise<Schemas["SchemaPublishResponse"]>;
+    publish(body: Schemas["SchemaPublishRequest"], opts?: CallOptions & {
+        dryRun?: boolean;
+    }): Promise<Schemas["SchemaPublishResponse"]>;
 }
 /** Ontology discovery and lifecycle operations. */
 export declare class OntologyNamespace {
@@ -114,7 +112,9 @@ export declare class OntologyNamespace {
      * does not exist yet. Safe to repeat. See {@link LbbClient.ontologyDefine}.
      */
     define(body: Schemas["OntologyDefineRequest"], opts?: CallOptions): Promise<Schemas["OntologyDefineResponse"]>;
-    evolve(body: Schemas["OntologyEvolveRequest"], opts?: CallOptions): Promise<Schemas["OntologyEvolveResponse"]>;
+    evolve(body: Schemas["OntologyEvolveRequest"], opts?: CallOptions & {
+        dryRun?: boolean;
+    }): Promise<Schemas["OntologyEvolveResponse"]>;
     induce(body: Schemas["OntologyInduceRequest"], opts?: CallOptions): Promise<Schemas["OntologyInduceResponse"]>;
 }
 /** Structured and SPARQL-text query operations. */

package/dist/namespaces.js

@@ -213,6 +213,7 @@ export class SchemaNamespace {
     publish(body, opts = {}) {
         return this.client.request("POST", "/v1/schema/publish", {
             ...opts,
+            query: { dry_run: opts.dryRun },
             idempotencyKey: opts.idempotencyKey ?? this.client.idempotencyKey("schema-publish"),
             body,
         });
@@ -266,6 +267,7 @@ export class OntologyNamespace {
     evolve(body, opts = {}) {
         return this.client.request("POST", "/v1/ontology/evolve", {
             ...opts,
+            query: { dry_run: opts.dryRun },
             body,
         });
     }

package/dist/schema.d.ts

@@ -232,7 +232,7 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** Entity detail */
+        /** Native entity attributes and relationships from the branch-owned RDF view; unavailable provenance sections are explicitly listed */
         get: operations["get_v1_graph_entity"];
         put?: never;
         post?: never;
@@ -1141,7 +1141,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Atomically activate a SHACL shapes bundle and enqueue durable conformance validation */
+        /** Atomically activate a SHACL shapes bundle, or preview compatibility without writes or validation jobs */
         post: operations["post_v1_schema_publish"];
         delete?: never;
         options?: never;
@@ -1973,12 +1973,9 @@ export interface components {
         };
         EntityDetailResponse: {
             /**
-             * @description The entity's typed scalar properties as native JSON — the flat read-back
-             *     of what a commit's `entity_properties` wrote, so round-trip verification
-             *     is a one-hop lookup. A numeric property reads back as a JSON number, a
-             *     bool as a bool, a datetime as an RFC3339 string; empty when the entity
-             *     carries no scalar attributes. The `/entities` list returns the same
-             *     `attributes` shape under `?fields=`.
+             * @description The entity's RDF-projected properties as typed JSON: numbers, booleans,
+             *     RFC3339 datetime strings, strings and sets. Nulls, bytes, vectors,
+             *     non-finite numbers and empty sets have no RDF projection and are omitted.
              */
             attributes?: {
                 [key: string]: unknown;
@@ -1990,8 +1987,14 @@ export interface components {
             metadata: components["schemas"]["EntityMetadataResponse"];
             observations: components["schemas"]["ObservationRow"][];
             outgoing: components["schemas"]["GraphEdgeRow"][];
+            rdf_relations?: null | components["schemas"]["EntityRdfRelations"];
             snapshot: components["schemas"]["SnapshotView"];
             truncation?: null | components["schemas"]["EntityDetailTruncation"];
+            /**
+             * @description Legacy sections unavailable in this read model. An empty listed section
+             *     means unavailable, not that the entity has no history or relationships.
+             */
+            unavailable_sections?: string[];
         };
         /**
          * @description Which of an entity read's degree-proportional collections were cut, and by
@@ -2198,6 +2201,12 @@ export interface components {
             remove_fields?: string[];
             type: string;
         };
+        EntityRdfRelations: {
+            incoming: components["schemas"]["RdfEntityRelation"][];
+            incoming_truncation?: null | components["schemas"]["TruncatedCollection"];
+            outgoing: components["schemas"]["RdfEntityRelation"][];
+            outgoing_truncation?: null | components["schemas"]["TruncatedCollection"];
+        };
         EntitySelector: {
             entity_id?: null | components["schemas"]["EntityId"];
             entity_type?: string | null;
@@ -3294,7 +3303,7 @@ export interface components {
             valid_time: components["schemas"]["ValidTime"];
         };
         /** @enum {string} */
-        HistoryObjectKind: "wal" | "segment" | "pending";
+        HistoryObjectKind: "wal" | "segment" | "unavailable" | "pending";
         HybridMultiSearchExplain: {
             fused_candidates: number;
             rrf_k: string;
@@ -4572,6 +4581,10 @@ export interface components {
              */
             rerank_raw_bytes_fetched?: number;
         };
+        RdfEntityRelation: {
+            entity: components["schemas"]["EntityView"];
+            relation: components["schemas"]["RelationView"];
+        };
         /**
          * @description The RDF node kind of a bounded observed-schema statement object.
          * @enum {string}
@@ -4979,6 +4992,7 @@ export interface components {
             ontology_version: number;
             /** Format: int64 */
             shapes_version?: number | null;
+            write_enforcement?: null | components["schemas"]["SchemaWriteEnforcement"];
         };
         SchemaRelationView: {
             dst_types: string[];
@@ -4990,6 +5004,12 @@ export interface components {
             src_types: string[];
             stable_id: string;
         };
+        SchemaShapeWriteEnforcement: {
+            blockers?: components["schemas"]["SchemaWriteEnforcementBlocker"][];
+            /** @description An active root shape: one that selects focus nodes. */
+            shape: string;
+            write_enforceable: boolean;
+        };
         SchemaSource: {
             /**
              * @description Format hint for this source. Ontology sources use the ontology importer
@@ -5001,6 +5021,36 @@ export interface components {
             /** @description RDF or ontology document text. */
             source: string;
         };
+        /** @description How the published shape set is enforced on this branch. */
+        SchemaWriteEnforcement: {
+            shapes: components["schemas"]["SchemaShapeWriteEnforcement"][];
+            timing: components["schemas"]["SchemaWriteEnforcementTiming"];
+            /**
+             * @description True when no root shape has a blocker. An RDF-native branch accepts
+             *     `reject` mode only for such a shape set.
+             */
+            write_enforceable: boolean;
+        };
+        /**
+         * @description A constraint with no bounded affected set: the engine cannot tell which
+         *     focus nodes a write changes its verdict for.
+         */
+        SchemaWriteEnforcementBlocker: {
+            /**
+             * @description The SHACL parameter: `sh:sparql`, or the shape reference that closes a
+             *     cycle (`sh:node`, `sh:property`, `sh:or`, ...).
+             */
+            constraint: string;
+            /** @description `sparql_constraint` or `recursive_shape`. */
+            reason: string;
+            /** @description The shape that carries the constraint. */
+            shape: string;
+        };
+        /**
+         * @description When the engine checks the published shapes against a write.
+         * @enum {string}
+         */
+        SchemaWriteEnforcementTiming: "write_time" | "write_time_full_scan" | "after_publication";
         /**
          * @description One scored retrieval candidate on the wire: which entity matched and its raw
          *     (pre-calibration) score from whatever channel produced it. The entity is
@@ -6068,6 +6118,7 @@ export interface components {
              *     the query into grouped/aggregated mode.
              */
             aggregates?: components["schemas"]["SparqlAggregate"][];
+            as_of_commit_seq?: null | components["schemas"]["CommitSeq"];
             /**
              * @description `ASK` form: return only `boolean` (whether the pattern has any solution).
              *     Projection, DISTINCT, and limit/offset are ignored.
@@ -8778,6 +8829,14 @@ export interface operations {
                 type?: string;
                 /** @description Entity canonical name for name-addressed lookup */
                 name?: string;
+                /** @description External entity key; takes precedence over name */
+                key?: string;
+                /** @description strong or eventual (default); strong includes the exact durable delta suffix */
+                consistency?: string;
+                /** @description Retained commit sequence; valid-time as_of is unsupported */
+                as_of_commit_seq?: string;
+                /** @description Maximum RDF relationships per direction (default 1000, ceiling 10000) */
+                edges?: string;
             };
             header?: {
                 /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */
@@ -17108,6 +17167,8 @@ export interface operations {
                 graph?: string;
                 /** @description Branch name (default `main`) */
                 branch?: string;
+                /** @description Parse and check compatibility without activation; returns activated=false and predicted schema versions. Does not run whole-graph conformance */
+                dry_run?: string;
             };
             header?: {
                 /** @description API contract version to pin. Use `2026-07-23` for this beta-breaking shape. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@littlebigbrain/client",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "TypeScript client for the little big brain graph + hybrid search HTTP API",
   "license": "Apache-2.0",
   "repository": {