@lucern/sdk 1.0.28 → 1.0.30

package/dist/beliefsClient.d.ts

@@ -1,27 +1,27 @@
-import { type GatewayClientConfig, LucernApiError, type PlatformGatewaySuccess } from "./coreClient";
+import { type GatewayClientConfig, LucernApiError } from "./coreClient";
 import type { ForkBeliefResponse, JsonObject } from "./types";
-export { LucernApiError };
 export type { PlatformGatewaySuccess } from "./coreClient";
-export type { CreateBeliefResponse, ForkBeliefResponse, } from "./types";
 export type { Opinion } from "./opinion";
+export type { CreateBeliefResponse, ForkBeliefResponse, } from "./types";
+export { LucernApiError };
 /** Configuration for the beliefs client. Inherits gateway transport settings. */
 export type BeliefsClientConfig = GatewayClientConfig;
-export type OpinionHistoryEntry = {
-    t: number;
+export interface OpinionHistoryEntry {
+    a: number;
     b: number;
     d: number;
-    u: number;
-    a: number;
     P: number;
+    rationale?: string;
+    slOperator?: string;
+    t: number;
     trigger: string;
     triggeringRef?: {
         kind: "evidence" | "question" | "answer" | "contradiction" | "worktree";
         id: string;
     };
-    rationale?: string;
+    u: number;
     userId?: string;
-    slOperator?: string;
-};
+}
 type GatewayRecord = Record<string, unknown>;
 export declare function mapOpinionHistoryEntriesFromGatewayData(payload: GatewayRecord): OpinionHistoryEntry[];
 /**
@@ -34,84 +34,92 @@ export declare function mapOpinionHistoryEntriesFromGatewayData(payload: Gateway
  * Beliefs start as drafts with a vacuous prior `(0, 0, 1, a)`. When omitted,
  * `baseRate` defaults to the canonical neutral prior `0.5`.
  */
-export type CreateBeliefInput = {
-    /** Required UUIDv7 topic epistemicNodes globalId. */
-    topicGlobalId: string;
-    /** Preferred belief statement alias. */
-    text?: string;
+export interface CreateBeliefInput {
+    baseRate?: number;
+    beliefStatus?: string;
+    beliefType?: string;
     /** @deprecated Use text. */
     canonicalText?: string;
-    layer?: "L1" | "L2" | "L3" | "L4";
-    domain?: string;
-    sourceType?: "human" | "ai" | "agent" | "imported";
+    confidence?: number;
     content?: string;
     contentHash?: string;
+    domain?: string;
     globalId?: string;
-    title?: string;
+    layer?: "L1" | "L2" | "L3" | "L4";
+    metadata?: JsonObject;
+    pillar?: string;
+    predictionMeta?: JsonObject;
+    rationale?: string;
+    reversibility?: string;
+    sourceBeliefIds?: string[];
+    sourceType?: "human" | "ai" | "agent" | "imported";
     subtype?: string;
-    confidence?: number;
-    baseRate?: number;
     tags?: string[];
-    metadata?: JsonObject;
+    /** Preferred belief statement alias. */
+    text?: string;
+    title?: string;
+    /** Required UUIDv7 topic epistemicNodes globalId. */
+    topicGlobalId: string;
     verificationStatus?: "unverified" | "verified" | "rejected";
-};
+    worktreeId?: string;
+}
 /**
  * Input for refining an existing draft belief.
  *
  * Use `text` as the canonical belief statement.
  * `canonicalText` remains available as a legacy alias for backwards compatibility.
  */
-export type RefineBeliefInput = {
-    /** Preferred belief statement alias. */
-    text?: string;
+export interface RefineBeliefInput {
     /** @deprecated Use text. */
     canonicalText?: string;
     rationale?: string;
+    /** Preferred belief statement alias. */
+    text?: string;
     title?: string;
-};
+}
 /**
  * Input for forking an evidence-bearing belief into a new formulation.
  * Every fork must cite evidence already attached to the parent through SL.
  */
-export type ForkBeliefInput = {
-    newFormulation: string;
-    forkReason: "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse";
+export interface ForkBeliefInput {
     forkMode?: "supersede" | "branch";
-    triggeringEvidenceId: string;
+    forkReason: "refinement" | "contradiction_response" | "scope_change" | "confidence_collapse";
+    newFormulation: string;
     rationale?: string;
-};
+    triggeringEvidenceId: string;
+}
 /** Input for updating a belief's rationale without refining its text. */
-export type UpdateBeliefRationaleInput = {
+export interface UpdateBeliefRationaleInput {
+    beliefId?: string;
     id?: string;
     nodeId?: string;
-    beliefId?: string;
     rationale?: string;
-};
+}
 /** Input for creating a belief-to-belief reasoning edge. */
-export type LinkBeliefsInput = {
+export interface LinkBeliefsInput {
+    context?: string;
+    edgeType: string;
     fromNodeId: string;
     toNodeId: string;
-    edgeType: string;
     weight?: number;
-    context?: string;
-};
+}
 /** Input for unlinking a belief from an attached evidence item. */
-export type UnlinkBeliefEvidenceInput = {
-    beliefNodeId?: string;
+export interface UnlinkBeliefEvidenceInput {
     beliefId?: string;
-    nodeId?: string;
-    insightId?: string;
+    beliefNodeId?: string;
     evidenceId?: string;
-};
-/** Input for updating a belief's criticality classification. */
-export type UpdateBeliefCriticalityInput = {
-    id?: string;
+    insightId?: string;
     nodeId?: string;
+}
+/** Input for updating a belief's criticality classification. */
+export interface UpdateBeliefCriticalityInput {
     beliefId?: string;
     criticality: "blocking" | "important" | "supporting" | "essential" | "nice_to_have";
-};
+    id?: string;
+    nodeId?: string;
+}
 /** Input for bulk-updating multiple beliefs' criticality. */
-export type BatchUpdateBeliefCriticalityInput = {
+export interface BatchUpdateBeliefCriticalityInput {
     updates: Array<{
         beliefId: string;
         criticality: "blocking" | "important" | "supporting" | "essential" | "nice_to_have";
@@ -121,14 +129,14 @@ export type BatchUpdateBeliefCriticalityInput = {
         dependentBeliefIds?: string[];
         blockedByBeliefIds?: string[];
     }>;
-};
+}
 /** Input for moving beliefs into a different topic scope. */
-export type ReassignBeliefsTopicInput = {
-    beliefNodeIds?: string[];
+export interface ReassignBeliefsTopicInput {
     beliefIds?: string[];
-    targetTopicId: string;
+    beliefNodeIds?: string[];
     reason?: string;
-};
+    targetTopicId: string;
+}
 /**
  * Create the beliefs client for belief lifecycle operations.
  *
@@ -139,11 +147,11 @@ export declare function createBeliefsClient(config?: BeliefsClientConfig): {
     /**
      * Create a belief within a topic scope.
      */
-    createBelief(input: CreateBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
+    createBelief(input: CreateBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
     /**
      * Refine a draft belief in place.
      */
-    refineBelief(beliefId: string, input: RefineBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
+    refineBelief(beliefId: string, input: RefineBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<import("./types").PlatformBeliefRecord>>;
     /**
      * Returns the belief's confidence trajectory as a chronological array.
      *
@@ -163,30 +171,30 @@ export declare function createBeliefsClient(config?: BeliefsClientConfig): {
     /**
      * Fork a scored belief into a new formulation.
      */
-    forkBelief(beliefId: string, input: ForkBeliefInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<ForkBeliefResponse>>;
+    forkBelief(beliefId: string, input: ForkBeliefInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<ForkBeliefResponse>>;
     /**
      * Update a belief's rationale without changing its text.
      */
-    updateBeliefRationale(input: UpdateBeliefRationaleInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    updateBeliefRationale(input: UpdateBeliefRationaleInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Create a typed relationship between two beliefs.
      */
-    linkBeliefs(input: LinkBeliefsInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    linkBeliefs(input: LinkBeliefsInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Remove an evidence attachment from a belief.
      */
-    unlinkBeliefEvidence(input: UnlinkBeliefEvidenceInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    unlinkBeliefEvidence(input: UnlinkBeliefEvidenceInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Update a belief's criticality metadata.
      */
-    updateBeliefCriticality(input: UpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    updateBeliefCriticality(input: UpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Update multiple beliefs' criticality in one mutation.
      */
-    batchUpdateBeliefCriticality(input: BatchUpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    batchUpdateBeliefCriticality(input: BatchUpdateBeliefCriticalityInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
     /**
      * Reassign beliefs to a different topic scope.
      */
-    reassignBeliefsTopic(input: ReassignBeliefsTopicInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
+    reassignBeliefsTopic(input: ReassignBeliefsTopicInput, idempotencyKey?: string): Promise<import("./coreClient").PlatformGatewaySuccess<Record<string, unknown>>>;
 };
 //# sourceMappingURL=beliefsClient.d.ts.map

package/dist/beliefsClient.js

@@ -1,6 +1,9 @@
-import { createGatewayRequestClient, LucernApiError, randomIdempotencyKey, } from "./coreClient.js";
-import { normalizeNodeWriteInput } from "./sdkSurface.js";
+// biome-ignore-all lint/style/useFilenamingConvention: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the camelCase filename is intentional.
 import { isUuidV7 } from "@lucern/contracts/ids";
+import { createGatewayRequestClient, 
+// biome-ignore lint/style/noExportedImports: beliefsClient preserves this legacy compatibility re-export while package root also exports coreClient.
+LucernApiError, randomIdempotencyKey, } from "./coreClient.js";
+import { normalizeNodeWriteInput } from "./sdkSurface.js";
 export { LucernApiError };
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
@@ -9,13 +12,15 @@ function asRecord(value) {
 }
 function readString(value) {
     if (typeof value !== "string") {
-        return undefined;
+        return;
     }
     const normalized = value.trim();
     return normalized.length > 0 ? normalized : undefined;
 }
 function readNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
 }
 function clamp01(value) {
     return Math.max(0, Math.min(1, value));
@@ -39,51 +44,67 @@ function normalizeOpinionTuple(record) {
         a: clamp01(rawBaseRate),
     };
 }
+function readOpinionTriggeringRef(record) {
+    const triggeringEvidenceId = readString(record.triggeringEvidenceId);
+    if (triggeringEvidenceId) {
+        return { kind: "evidence", id: triggeringEvidenceId };
+    }
+    const triggeringQuestionId = readString(record.triggeringQuestionId);
+    if (triggeringQuestionId) {
+        return { kind: "question", id: triggeringQuestionId };
+    }
+    const triggeringAnswerId = readString(record.triggeringAnswerId);
+    if (triggeringAnswerId) {
+        return { kind: "answer", id: triggeringAnswerId };
+    }
+    const triggeringContradictionId = readString(record.triggeringContradictionId);
+    if (triggeringContradictionId) {
+        return { kind: "contradiction", id: triggeringContradictionId };
+    }
+    const triggeringWorktreeId = readString(record.triggeringWorktreeId);
+    return triggeringWorktreeId
+        ? { kind: "worktree", id: triggeringWorktreeId }
+        : undefined;
+}
+function mapOpinionHistoryEntry(value) {
+    const record = asRecord(value);
+    const tuple = normalizeOpinionTuple(record);
+    const projected = readNumber(record.confidence) ?? clamp01(tuple.b + tuple.a * tuple.u);
+    const trigger = readString(record.trigger);
+    if (!trigger) {
+        throw new Error("Gateway opinion history entries must include trigger.");
+    }
+    const entry = {
+        t: readNumber(record.timestamp) ?? readNumber(record.assessedAt) ?? 0,
+        b: tuple.b,
+        d: tuple.d,
+        u: tuple.u,
+        a: tuple.a,
+        P: clamp01(projected),
+        trigger,
+    };
+    const triggeringRef = readOpinionTriggeringRef(record);
+    if (triggeringRef) {
+        entry.triggeringRef = triggeringRef;
+    }
+    const rationale = readString(record.rationale);
+    if (rationale) {
+        entry.rationale = rationale;
+    }
+    const userId = readString(record.userId);
+    if (userId) {
+        entry.userId = userId;
+    }
+    const slOperator = readString(record.slOperator);
+    if (slOperator) {
+        entry.slOperator = slOperator;
+    }
+    return entry;
+}
 export function mapOpinionHistoryEntriesFromGatewayData(payload) {
     const entries = Array.isArray(payload.entries) ? payload.entries : [];
     return entries
-        .map((value) => {
-        const record = asRecord(value);
-        const tuple = normalizeOpinionTuple(record);
-        const projected = readNumber(record.confidence) ?? clamp01(tuple.b + tuple.a * tuple.u);
-        const triggeringEvidenceId = readString(record.triggeringEvidenceId);
-        const triggeringQuestionId = readString(record.triggeringQuestionId);
-        const triggeringAnswerId = readString(record.triggeringAnswerId);
-        const triggeringContradictionId = readString(record.triggeringContradictionId);
-        const triggeringWorktreeId = readString(record.triggeringWorktreeId);
-        const triggeringRef = triggeringEvidenceId
-            ? { kind: "evidence", id: triggeringEvidenceId }
-            : triggeringQuestionId
-                ? { kind: "question", id: triggeringQuestionId }
-                : triggeringAnswerId
-                    ? { kind: "answer", id: triggeringAnswerId }
-                    : triggeringContradictionId
-                        ? { kind: "contradiction", id: triggeringContradictionId }
-                        : triggeringWorktreeId
-                            ? { kind: "worktree", id: triggeringWorktreeId }
-                            : undefined;
-        const trigger = readString(record.trigger);
-        if (!trigger) {
-            throw new Error("Gateway opinion history entries must include trigger.");
-        }
-        return {
-            t: readNumber(record.timestamp) ?? readNumber(record.assessedAt) ?? 0,
-            b: tuple.b,
-            d: tuple.d,
-            u: tuple.u,
-            a: tuple.a,
-            P: clamp01(projected),
-            trigger,
-            ...(triggeringRef ? { triggeringRef } : {}),
-            ...(readString(record.rationale)
-                ? { rationale: readString(record.rationale) }
-                : {}),
-            ...(readString(record.userId) ? { userId: readString(record.userId) } : {}),
-            ...(readString(record.slOperator)
-                ? { slOperator: readString(record.slOperator) }
-                : {}),
-        };
-    })
+        .map(mapOpinionHistoryEntry)
         .sort((left, right) => left.t - right.t);
 }
 /**
@@ -104,13 +125,13 @@ export function createBeliefsClient(config = {}) {
     }
     function normalizeCreateBeliefInput(input) {
         const topicGlobalId = readString(input.topicGlobalId);
-        if (!topicGlobalId || !isUuidV7(topicGlobalId)) {
+        if (!(topicGlobalId && isUuidV7(topicGlobalId))) {
             throw new Error("createBelief requires topicGlobalId to be a UUIDv7 topic epistemic-node globalId.");
         }
         const text = readString(input.text) ?? readString(input.canonicalText);
         const body = { ...input, topicGlobalId };
-        delete body.topicId;
-        delete body.topicNodeId;
+        body.topicId = undefined;
+        body.topicNodeId = undefined;
         if (text) {
             body.text = text;
             body.canonicalText = text;
@@ -127,22 +148,24 @@ export function createBeliefsClient(config = {}) {
         /**
          * Create a belief within a topic scope.
          */
-        async createBelief(input, idempotencyKey) {
-            const baseRate = normalizeBaseRate(input.baseRate);
-            return gateway.request({
-                path: "/api/platform/v1/beliefs",
-                method: "POST",
-                body: {
-                    ...normalizeCreateBeliefInput(input),
-                    baseRate,
-                },
-                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+        createBelief(input, idempotencyKey) {
+            return Promise.resolve().then(() => {
+                const baseRate = normalizeBaseRate(input.baseRate);
+                return gateway.request({
+                    path: "/api/platform/v1/beliefs",
+                    method: "POST",
+                    body: {
+                        ...normalizeCreateBeliefInput(input),
+                        baseRate,
+                    },
+                    idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+                });
             });
         },
         /**
          * Refine a draft belief in place.
          */
-        async refineBelief(beliefId, input, idempotencyKey) {
+        refineBelief(beliefId, input, idempotencyKey) {
             return gateway.request({
                 path: `/api/platform/v1/beliefs/${encodeURIComponent(beliefId)}`,
                 method: "PATCH",
@@ -169,7 +192,7 @@ export function createBeliefsClient(config = {}) {
         /**
          * Fork a scored belief into a new formulation.
          */
-        async forkBelief(beliefId, input, idempotencyKey) {
+        forkBelief(beliefId, input, idempotencyKey) {
             return gateway.request({
                 path: `/api/platform/v1/beliefs/${encodeURIComponent(beliefId)}/fork`,
                 method: "POST",
@@ -180,7 +203,7 @@ export function createBeliefsClient(config = {}) {
         /**
          * Update a belief's rationale without changing its text.
          */
-        async updateBeliefRationale(input, idempotencyKey) {
+        updateBeliefRationale(input, idempotencyKey) {
             return gateway.request({
                 path: "/api/platform/v1/beliefs/update-rationale",
                 method: "POST",
@@ -191,7 +214,7 @@ export function createBeliefsClient(config = {}) {
         /**
          * Create a typed relationship between two beliefs.
          */
-        async linkBeliefs(input, idempotencyKey) {
+        linkBeliefs(input, idempotencyKey) {
             return gateway.request({
                 path: "/api/platform/v1/beliefs/link",
                 method: "POST",
@@ -202,7 +225,7 @@ export function createBeliefsClient(config = {}) {
         /**
          * Remove an evidence attachment from a belief.
          */
-        async unlinkBeliefEvidence(input, idempotencyKey) {
+        unlinkBeliefEvidence(input, idempotencyKey) {
             return gateway.request({
                 path: "/api/platform/v1/beliefs/unlink-evidence",
                 method: "POST",
@@ -213,7 +236,7 @@ export function createBeliefsClient(config = {}) {
         /**
          * Update a belief's criticality metadata.
          */
-        async updateBeliefCriticality(input, idempotencyKey) {
+        updateBeliefCriticality(input, idempotencyKey) {
             return gateway.request({
                 path: "/api/platform/v1/beliefs/update-criticality",
                 method: "POST",
@@ -224,7 +247,7 @@ export function createBeliefsClient(config = {}) {
         /**
          * Update multiple beliefs' criticality in one mutation.
          */
-        async batchUpdateBeliefCriticality(input, idempotencyKey) {
+        batchUpdateBeliefCriticality(input, idempotencyKey) {
             return gateway.request({
                 path: "/api/platform/v1/beliefs/batch-update-criticality",
                 method: "POST",
@@ -235,7 +258,7 @@ export function createBeliefsClient(config = {}) {
         /**
          * Reassign beliefs to a different topic scope.
          */
-        async reassignBeliefsTopic(input, idempotencyKey) {
+        reassignBeliefsTopic(input, idempotencyKey) {
             return gateway.request({
                 path: "/api/platform/v1/beliefs/reassign-topic",
                 method: "POST",

package/dist/{boundaryClientSurface.d.ts → boundary-client-surface.d.ts}

@@ -1,9 +1,9 @@
 import type { JsonObject, ListResult } from "./types";
-export type TopicProjectAliasInput = {
-    topicId?: string;
+export interface TopicProjectAliasInput {
     /** @deprecated Use topicId. */
     projectId?: string;
-};
+    topicId?: string;
+}
 export declare function cleanOptionalString(value: string | undefined): string | undefined;
 export declare function cleanRequiredString(value: string | undefined, label: string): string;
 export declare function readTopicId(input: TopicProjectAliasInput): string | undefined;
@@ -12,4 +12,4 @@ export declare function assertKnownKeys<T extends string>(input: Record<string,
 export declare function knownPayload<T extends string>(input: Record<string, unknown>, allowed: readonly T[], operation: string): JsonObject;
 export declare function topicPayload<T extends string>(input: TopicProjectAliasInput & Record<string, unknown>, allowed: readonly T[], operation: string): JsonObject;
 export declare function listResultFromEnvelope<T, LegacyKey extends string>(data: unknown, legacyKey: LegacyKey): ListResult<T, LegacyKey>;
-//# sourceMappingURL=boundaryClientSurface.d.ts.map
+//# sourceMappingURL=boundary-client-surface.d.ts.map

package/dist/{boundaryClientSurface.js → boundary-client-surface.js}

@@ -14,7 +14,7 @@ export function cleanRequiredString(value, label) {
     return normalized;
 }
 export function readTopicId(input) {
-    return cleanOptionalString(input.topicId) ?? cleanOptionalString(input.projectId);
+    return (cleanOptionalString(input.topicId) ?? cleanOptionalString(input.projectId));
 }
 export function requireTopicId(input) {
     const topicId = readTopicId(input);
@@ -45,10 +45,12 @@ export function topicPayload(input, allowed, operation) {
 export function listResultFromEnvelope(data, legacyKey) {
     const record = isRecord(data) ? data : {};
     const legacyItems = record[legacyKey];
-    return createListResult(Array.isArray(legacyItems)
-        ? legacyItems
-        : Array.isArray(data)
-            ? data
-            : [], legacyKey);
+    if (Array.isArray(legacyItems)) {
+        return createListResult(legacyItems, legacyKey);
+    }
+    if (Array.isArray(data)) {
+        return createListResult(data, legacyKey);
+    }
+    return createListResult([], legacyKey);
 }
-//# sourceMappingURL=boundaryClientSurface.js.map
+//# sourceMappingURL=boundary-client-surface.js.map