@lucern/sdk 1.0.29 → 1.0.31

package/dist/contextClient.js

@@ -1,18 +1,23 @@
 import { createGatewayRequestClient, } from "./coreClient.js";
+function deferGatewayRequest(buildRequest) {
+    return Promise.resolve().then(buildRequest);
+}
 function cleanString(value) {
     return typeof value === "string" && value.trim().length > 0
         ? value.trim()
         : undefined;
 }
 function cleanNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
 }
 function cleanBoolean(value) {
     return typeof value === "boolean" ? value : undefined;
 }
 function cleanStringArray(value) {
     if (!Array.isArray(value)) {
-        return undefined;
+        return;
     }
     const cleaned = value
         .map((item) => cleanString(item))
@@ -31,96 +36,120 @@ function assignNumber(payload, key, value) {
         payload[key] = cleaned;
     }
 }
-function buildCompileContextRequest(topicIdOrInput = {}, input = {}) {
-    const effectiveInput = typeof topicIdOrInput === "string" ? input : topicIdOrInput;
-    const payload = {};
+function effectiveCompileInput(topicIdOrInput, input) {
+    return typeof topicIdOrInput === "string" ? input : topicIdOrInput;
+}
+function assignCompileTopicAndQuery(payload, topicIdOrInput, input) {
     const topicId = typeof topicIdOrInput === "string"
         ? cleanString(topicIdOrInput)
-        : cleanString(effectiveInput.topicId);
+        : cleanString(input.topicId);
     if (topicId) {
         payload.topicId = topicId;
     }
-    const query = cleanString(effectiveInput.query);
+    const query = cleanString(input.query);
     if (query) {
         payload.query = query;
     }
-    assignString(payload, "purpose", effectiveInput.purpose);
-    assignString(payload, "purposePrompt", effectiveInput.purposePrompt);
-    assignString(payload, "topicHint", effectiveInput.topicHint);
-    const tags = cleanStringArray(effectiveInput.tags);
+}
+function assignCompileStringMetadata(payload, input) {
+    assignString(payload, "purpose", input.purpose);
+    assignString(payload, "purposePrompt", input.purposePrompt);
+    assignString(payload, "topicHint", input.topicHint);
+    assignString(payload, "sourceRef", input.sourceRef);
+    assignString(payload, "sourceKind", input.sourceKind);
+    assignString(payload, "lane", input.lane);
+    assignString(payload, "status", input.status);
+    assignString(payload, "principalId", input.principalId);
+    assignString(payload, "workspaceId", input.workspaceId);
+}
+function assignCompileArrayMetadata(payload, input) {
+    const tags = cleanStringArray(input.tags);
     if (tags) {
         payload.tags = tags;
     }
-    const touchedPaths = cleanStringArray(effectiveInput.touchedPaths);
+    const touchedPaths = cleanStringArray(input.touchedPaths);
     if (touchedPaths) {
         payload.touchedPaths = touchedPaths;
     }
-    assignString(payload, "sourceRef", effectiveInput.sourceRef);
-    assignString(payload, "sourceKind", effectiveInput.sourceKind);
-    assignNumber(payload, "campaign", effectiveInput.campaign);
-    assignString(payload, "lane", effectiveInput.lane);
-    assignString(payload, "status", effectiveInput.status);
-    assignString(payload, "principalId", effectiveInput.principalId);
-    assignString(payload, "workspaceId", effectiveInput.workspaceId);
-    const budget = cleanNumber(effectiveInput.budget);
+}
+function assignCompileBudgets(payload, input) {
+    assignNumber(payload, "campaign", input.campaign);
+    const budget = cleanNumber(input.budget);
     if (budget !== undefined) {
         payload.budget = budget;
     }
-    const tokenBudget = cleanNumber(effectiveInput.tokenBudget);
+    const tokenBudget = cleanNumber(input.tokenBudget);
     if (tokenBudget !== undefined) {
         payload.tokenBudget = tokenBudget;
         if (budget === undefined) {
             payload.budget = tokenBudget;
         }
     }
-    const ranking = cleanString(effectiveInput.ranking) ?? cleanString(effectiveInput.rankingProfile);
+    assignNumber(payload, "contentTopicLimit", input.contentTopicLimit);
+}
+function assignCompileTraversal(payload, input) {
+    const ranking = cleanString(input.ranking) ?? cleanString(input.rankingProfile);
     if (ranking) {
         payload.ranking = ranking;
     }
-    const limit = cleanNumber(effectiveInput.limit);
+    const limit = cleanNumber(input.limit);
     if (limit !== undefined) {
         payload.limit = limit;
     }
-    assignNumber(payload, "contentTopicLimit", effectiveInput.contentTopicLimit);
-    const maxDepth = cleanNumber(effectiveInput.maxDepth);
+    const maxDepth = cleanNumber(input.maxDepth);
     if (maxDepth !== undefined) {
         payload.maxDepth = maxDepth;
     }
-    const includeEntities = cleanBoolean(effectiveInput.includeEntities);
+    const includeEntities = cleanBoolean(input.includeEntities);
     if (includeEntities !== undefined) {
         payload.includeEntities = includeEntities;
     }
-    const mode = cleanString(effectiveInput.mode);
+    const mode = cleanString(input.mode);
     if (mode) {
         payload.mode = mode;
     }
-    assignString(payload, "traversalMode", effectiveInput.traversalMode);
-    assignString(payload, "requestedDepth", effectiveInput.requestedDepth);
-    const heartbeat = cleanBoolean(effectiveInput.heartbeat);
+    assignString(payload, "traversalMode", input.traversalMode);
+    assignString(payload, "requestedDepth", input.requestedDepth);
+}
+function assignCompileHeartbeat(payload, input) {
+    const heartbeat = cleanBoolean(input.heartbeat);
     if (heartbeat !== undefined) {
         payload.heartbeat = heartbeat;
     }
-    assignString(payload, "heartbeatIntent", effectiveInput.heartbeatIntent);
-    assignNumber(payload, "heartbeatBudgetMs", effectiveInput.heartbeatBudgetMs);
-    assignString(payload, "heartbeatTraceId", effectiveInput.heartbeatTraceId);
-    assignString(payload, "invocationIntent", effectiveInput.invocationIntent);
-    assignString(payload, "receiptIntent", effectiveInput.receiptIntent);
-    const includeFailures = cleanBoolean(effectiveInput.includeFailures);
+    assignString(payload, "heartbeatIntent", input.heartbeatIntent);
+    assignNumber(payload, "heartbeatBudgetMs", input.heartbeatBudgetMs);
+    assignString(payload, "heartbeatTraceId", input.heartbeatTraceId);
+    assignString(payload, "invocationIntent", input.invocationIntent);
+    assignString(payload, "receiptIntent", input.receiptIntent);
+}
+function assignCompileOptionalControls(payload, input) {
+    const includeFailures = cleanBoolean(input.includeFailures);
     if (includeFailures !== undefined) {
         payload.includeFailures = includeFailures;
     }
-    const worktreeId = cleanString(effectiveInput.worktreeId);
+    const worktreeId = cleanString(input.worktreeId);
     if (worktreeId) {
         payload.worktreeId = worktreeId;
     }
-    const sessionId = cleanString(effectiveInput.sessionId);
+    const sessionId = cleanString(input.sessionId);
     if (sessionId) {
         payload.sessionId = sessionId;
     }
-    if (Array.isArray(effectiveInput.packWeightOverrides) &&
-        effectiveInput.packWeightOverrides.length > 0) {
-        payload.packWeightOverrides = effectiveInput.packWeightOverrides;
+    if (Array.isArray(input.packWeightOverrides) &&
+        input.packWeightOverrides.length > 0) {
+        payload.packWeightOverrides = input.packWeightOverrides;
     }
+}
+function buildCompileContextRequest(topicIdOrInput = {}, input = {}) {
+    const effectiveInput = effectiveCompileInput(topicIdOrInput, input);
+    const payload = {};
+    assignCompileTopicAndQuery(payload, topicIdOrInput, effectiveInput);
+    assignCompileStringMetadata(payload, effectiveInput);
+    assignCompileArrayMetadata(payload, effectiveInput);
+    assignCompileBudgets(payload, effectiveInput);
+    assignCompileTraversal(payload, effectiveInput);
+    assignCompileHeartbeat(payload, effectiveInput);
+    assignCompileOptionalControls(payload, effectiveInput);
     return {
         path: "/api/platform/v1/context/compile",
         method: "POST",
@@ -160,26 +189,26 @@ export function createContextClient(config = {}) {
          * @param input - Optional compile parameters (query, budget, ranking, etc.).
          * @returns The compiled context payload with beliefs, questions, and evidence.
          */
-        async compile(topicIdOrInput = {}, input = {}) {
+        compile(topicIdOrInput = {}, input = {}) {
             const request = buildCompileContextRequest(topicIdOrInput, input);
-            return gateway.request({
+            return deferGatewayRequest(() => gateway.request({
                 ...request,
                 body: request.body,
-            });
+            }));
         },
-        async compileByQuery(input = {}) {
+        compileByQuery(input = {}) {
             const request = buildCompileContextRequest(input);
-            return gateway.request({
+            return deferGatewayRequest(() => gateway.request({
                 ...request,
                 body: request.body,
-            });
+            }));
         },
-        async getCampaignContext(input) {
+        getCampaignContext(input) {
             const request = buildGetCampaignContextRequest(input);
-            return gateway.request({
+            return deferGatewayRequest(() => gateway.request({
                 ...request,
                 body: request.body,
-            });
+            }));
         },
     };
 }

package/dist/contextFacade.d.ts

@@ -7,5 +7,5 @@
  *
  * Added: EK-16 T7.3.4 (2026-04-18).
  */
-export { createContextFacade, type ContextFacadeConfig, type ContextFacadeTransport, } from "./facade/context";
+export { type ContextFacadeConfig, type ContextFacadeTransport, createContextFacade, } from "./facade/context";
 //# sourceMappingURL=contextFacade.d.ts.map

package/dist/contextFacade.js

@@ -1,3 +1,5 @@
+// biome-ignore-all lint/style/useFilenamingConvention: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the camelCase filename is intentional.
+// biome-ignore-all lint/performance/noBarrelFile: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the facade/barrel export is intentional.
 /**
  * Context facade factory exposed for testing / audit tooling.
  *

package/dist/contextPackCompiler.d.ts

@@ -1,100 +1,100 @@
-import { type ContextCompilationMode, type ContextPackV1, type PackWeightOverride, type ContextRankingProfile } from "./contracts/context-pack.contract";
 import { resolveEffectiveWeights } from "./contextPackPolicy";
-export type ContextPackTopicRow = {
+import { type ContextCompilationMode, type ContextPackV1, type ContextRankingProfile, type PackWeightOverride } from "./contracts/context-pack.contract";
+export interface ContextPackTopicRow {
     _id: string;
+    createdAt?: number;
+    depth?: number;
+    generatedAt?: number;
     name?: string;
     parentTopicId?: string;
-    depth?: number;
     status?: string;
     updatedAt?: number;
-    createdAt?: number;
-    generatedAt?: number;
-};
-type ContextPackBeliefRow = {
+}
+interface ContextPackBeliefRow {
     _id: string;
+    beliefType?: string;
     canonicalText?: string;
     confidence?: number;
-    beliefType?: string;
-    status?: string;
+    createdAt?: number;
     metadata?: Record<string, unknown>;
+    status?: string;
     updatedAt?: number;
-    createdAt?: number;
-};
-type ContextPackQuestionRow = {
+}
+interface ContextPackQuestionRow {
     _id: string;
     canonicalText?: string;
-    status?: string;
+    createdAt?: number;
     metadata?: Record<string, unknown>;
+    status?: string;
     updatedAt?: number;
-    createdAt?: number;
-};
-type ContextPackEvidenceRow = {
+}
+interface ContextPackEvidenceRow {
     _id: string;
     canonicalText?: string;
-    sourceUrl?: string;
+    createdAt?: number;
     metadata?: Record<string, unknown>;
+    sourceUrl?: string;
     updatedAt?: number;
-    createdAt?: number;
-};
-type ContextPackContradictionRow = {
+}
+interface ContextPackContradictionRow {
     _id?: string;
-    globalId?: string;
-    weight?: number;
     context?: string;
+    createdAt?: number;
     description?: string;
+    globalId?: string;
     summary?: string;
     updatedAt?: number;
-    createdAt?: number;
-};
-type ContextPackEntityRow = {
+    weight?: number;
+}
+interface ContextPackEntityRow {
     _id: string;
-    nodeType?: string;
-    title?: string;
     canonicalText?: string;
     connectedBeliefCount?: number;
     connectedEvidenceCount?: number;
     metadata?: Record<string, unknown>;
+    nodeType?: string;
+    title?: string;
     updatedAt?: number;
-};
-type ContextPackFailureRow = {
+}
+interface ContextPackFailureRow {
     _id: string;
     canonicalText?: string;
+    createdAt?: number;
     metadata?: Record<string, unknown>;
     updatedAt?: number;
-    createdAt?: number;
-};
-export type CompileContextPackPlan = {
-    topicId: string;
-    queryText?: string;
-    tokens: string[];
-    limit: number;
-    rankingProfile: ContextRankingProfile;
-    tokenBudget: number;
+}
+export interface CompileContextPackPlan {
+    compilationMode: ContextCompilationMode;
     descendantDepth: number;
+    effectiveWeights: ReturnType<typeof resolveEffectiveWeights>;
     includeEntities: boolean;
-    compilationMode: ContextCompilationMode;
     includeFailures: boolean;
-    worktreeId?: string;
-    sessionId?: string;
+    limit: number;
     packWeightOverrides?: PackWeightOverride[];
-    effectiveWeights: ReturnType<typeof resolveEffectiveWeights>;
+    queryText?: string;
+    rankingProfile: ContextRankingProfile;
     scopedTopicIds: string[];
-};
-export type CompileContextPackPlanInput = {
-    args: Record<string, unknown> | undefined;
-    topic: ContextPackTopicRow;
+    sessionId?: string;
+    tokenBudget: number;
+    tokens: string[];
+    topicId: string;
+    worktreeId?: string;
+}
+export interface CompileContextPackPlanInput {
     allTopics: ContextPackTopicRow[];
-};
-export type CompileContextPackSnapshot = {
+    args: Record<string, unknown> | undefined;
     topic: ContextPackTopicRow;
-    plan: CompileContextPackPlan;
+}
+export interface CompileContextPackSnapshot {
     beliefs: ContextPackBeliefRow[];
-    questions: ContextPackQuestionRow[];
-    evidence: ContextPackEvidenceRow[];
     contradictions: ContextPackContradictionRow[];
     entities: ContextPackEntityRow[];
+    evidence: ContextPackEvidenceRow[];
     failures?: ContextPackFailureRow[];
-};
+    plan: CompileContextPackPlan;
+    questions: ContextPackQuestionRow[];
+    topic: ContextPackTopicRow;
+}
 export declare function planContextPackCompilation(input: CompileContextPackPlanInput): CompileContextPackPlan;
 export declare function compileContextPackFromSnapshot(snapshot: CompileContextPackSnapshot): ContextPackV1;
 export {};