@benz-ai-x/dsh-research-graph 0.1.5-rc.1

package/lib/types/client.d.ts

@@ -0,0 +1,127 @@
+import { S as SessionDigestResult, _ as DiscussionSearchResult, a as ExtractionPreparation, c as ExtractionResult, d as KnowledgeSave, f as KnowledgeSearch, g as DiscussionSearchRequest, h as ResearchTopicWrite, i as KnowledgeExportResult, l as KnowledgeCard, m as ResearchTopicSnapshot, n as ResearchReuseRecord, o as ExtractionPreparationRequest, p as ResearchTopic, r as KnowledgeExportRequest, s as ExtractionRequest, t as ResearchReusePreparation, u as KnowledgeMembership, v as SessionHistoryRequest, y as SessionHistoryResult } from "./research-reuse-3HT5WE0E.js";
+import { Context } from "@deepseek-ai/cordis";
+import { SessionId } from "@deepseek-ai/dsh-session/types";
+import { ConvViewProps } from "@deepseek-ai/dsh-client-ui-conversation/client";
+import { InjectFace, PropsLocale } from "@deepseek-ai/dsh-client-ui-slots";
+import { RemoteResult } from "@deepseek-ai/dsh-typert-protocol";
+//#region src/client/knowledge-remote.d.ts
+interface KnowledgeApi {
+  readonly prepareExport: (request: KnowledgeExportRequest, signal: AbortSignal) => Promise<KnowledgeExportResult>;
+  readonly prepareExtraction: (request: ExtractionPreparationRequest, signal: AbortSignal) => Promise<ExtractionPreparation>;
+  readonly extract: (request: ExtractionRequest, signal: AbortSignal) => Promise<ExtractionResult>;
+  readonly read: (request: {
+    readonly cardId: string;
+  }, signal: AbortSignal) => Promise<KnowledgeCard | null>;
+  readonly save: (request: KnowledgeSave, signal: AbortSignal) => Promise<KnowledgeCard>;
+  readonly search: (request: KnowledgeSearch, signal: AbortSignal) => Promise<readonly KnowledgeCard[]>;
+  readonly membership: (request: KnowledgeMembership, signal: AbortSignal) => Promise<KnowledgeCard>;
+}
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface TypertRemoteMap {
+    'sessionGraphKnowledge/prepareExport': (request: KnowledgeExportRequest, signal?: AbortSignal) => Promise<RemoteResult<KnowledgeExportResult>>;
+    'sessionGraphKnowledge/hostIdentity': (signal?: AbortSignal) => Promise<RemoteResult<{
+      readonly hostId: string;
+    }>>;
+    'sessionGraphKnowledge/prepareExtraction': (request: ExtractionPreparationRequest, signal?: AbortSignal) => Promise<RemoteResult<ExtractionPreparation>>;
+    'sessionGraphKnowledge/extract': (request: ExtractionRequest, signal?: AbortSignal) => Promise<RemoteResult<ExtractionResult>>;
+    'sessionGraphKnowledge/read': (request: {
+      readonly cardId: string;
+    }, signal?: AbortSignal) => Promise<RemoteResult<KnowledgeCard | null>>;
+    'sessionGraphKnowledge/save': (request: KnowledgeSave, signal?: AbortSignal) => Promise<RemoteResult<KnowledgeCard>>;
+    'sessionGraphKnowledge/search': (request: KnowledgeSearch, signal?: AbortSignal) => Promise<RemoteResult<readonly KnowledgeCard[]>>;
+    'sessionGraphKnowledge/membership': (request: KnowledgeMembership, signal?: AbortSignal) => Promise<RemoteResult<KnowledgeCard>>;
+  }
+  interface TypertRemoteNamespaceMap {
+    sessionGraphKnowledge: {
+      prepareExport: TypertRemoteMap['sessionGraphKnowledge/prepareExport'];
+      hostIdentity: TypertRemoteMap['sessionGraphKnowledge/hostIdentity'];
+      prepareExtraction: TypertRemoteMap['sessionGraphKnowledge/prepareExtraction'];
+      extract: TypertRemoteMap['sessionGraphKnowledge/extract'];
+      read: TypertRemoteMap['sessionGraphKnowledge/read'];
+      save: TypertRemoteMap['sessionGraphKnowledge/save'];
+      search: TypertRemoteMap['sessionGraphKnowledge/search'];
+      membership: TypertRemoteMap['sessionGraphKnowledge/membership'];
+    };
+  }
+}
+//#endregion
+//#region src/client/research-reuse-remote.d.ts
+interface ResearchReuseApi {
+  readonly prepare: (request: ResearchReusePreparation, signal: AbortSignal) => Promise<ResearchReuseRecord>;
+  readonly submit: (request: {
+    readonly operationId: string;
+  }, signal: AbortSignal) => Promise<ResearchReuseRecord>;
+  readonly read: (request: {
+    readonly operationId: string;
+  }, signal: AbortSignal) => Promise<ResearchReuseRecord | null>;
+  readonly forSession: (request: {
+    readonly sessionId: string;
+  }, signal: AbortSignal) => Promise<readonly ResearchReuseRecord[]>;
+}
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface TypertRemoteMap {
+    'sessionGraphReuse/prepare': (request: ResearchReusePreparation, signal?: AbortSignal) => Promise<RemoteResult<ResearchReuseRecord>>;
+    'sessionGraphReuse/submit': (request: {
+      readonly operationId: string;
+    }, signal?: AbortSignal) => Promise<RemoteResult<ResearchReuseRecord>>;
+    'sessionGraphReuse/read': (request: {
+      readonly operationId: string;
+    }, signal?: AbortSignal) => Promise<RemoteResult<ResearchReuseRecord | null>>;
+    'sessionGraphReuse/forSession': (request: {
+      readonly sessionId: string;
+    }, signal?: AbortSignal) => Promise<RemoteResult<readonly ResearchReuseRecord[]>>;
+  }
+  interface TypertRemoteNamespaceMap {
+    sessionGraphReuse: {
+      prepare: TypertRemoteMap['sessionGraphReuse/prepare'];
+      submit: TypertRemoteMap['sessionGraphReuse/submit'];
+      read: TypertRemoteMap['sessionGraphReuse/read'];
+      forSession: TypertRemoteMap['sessionGraphReuse/forSession'];
+    };
+  }
+}
+//#endregion
+//#region src/client/GraphView.d.ts
+/** Business face the browser entry injects into the view (navigation verbs). */
+interface GraphViewInjected {
+  readonly hostId: string;
+  readonly reuse: ResearchReuseApi;
+  readonly knowledge: KnowledgeApi;
+  topics: {
+    readonly list: (signal: AbortSignal) => Promise<readonly ResearchTopic[]>;
+    readonly read: (request: {
+      readonly topicId: string;
+    }, signal: AbortSignal) => Promise<ResearchTopicSnapshot>;
+    readonly write: (request: ResearchTopicWrite, signal: AbortSignal) => Promise<ResearchTopic>;
+  };
+  searchDiscussion: (request: DiscussionSearchRequest, signal: AbortSignal) => Promise<DiscussionSearchResult>;
+  /** Read addressed discussion text without activating an Agent. */
+  readSessionHistory: (request: SessionHistoryRequest, signal: AbortSignal) => Promise<SessionHistoryResult>;
+  /** Open one session on its own last view (double-click and panel verb). */
+  openSession: (id: SessionId) => void;
+  /** Create a Branch from one session (the panel's New-branch verb). */
+  branchSession: (id: SessionId) => Promise<void>;
+  /** Explicitly generate or refresh one read-only Session Digest. */
+  generateSessionDigest: (id: SessionId, options: {
+    readonly refresh: boolean;
+  }, signal: AbortSignal) => Promise<SessionDigestResult>;
+  /** Create, capture, and open one independent Merge Session. */
+  mergeSessions: (sourceIds: readonly SessionId[], instruction: string, signal: AbortSignal) => Promise<SessionId>;
+  /** Retry a failed Merge using its already-created target Session. */
+  retrySessionMerge: (targetSessionId: SessionId, sourceIds: readonly SessionId[], instruction: string, signal: AbortSignal) => Promise<SessionId>;
+}
+/** The graph view tab's composed props: runtime share + inject face + locale. */
+type GraphViewProps = ConvViewProps & InjectFace<GraphViewInjected> & PropsLocale<'sessionGraph'>;
+//#endregion
+//#region src/client/index.d.ts
+/** Required services: the conversation view slot, the sessions list, and the locale service. */
+declare const inject: string[];
+/**
+ * Mount the Digest, Merge, and History Remotes, then register the Graph UI
+ * inside a child Context that explicitly depends on those namespaces.
+ * @param ctx - client root context.
+ * @returns disposer that removes the UI before unmounting its Remote.
+ */
+declare function apply(ctx: Context): Promise<() => Promise<void>>;
+//#endregion
+export { type GraphViewInjected, type GraphViewProps, apply, inject };

package/lib/types/index.d.ts

@@ -0,0 +1,240 @@
+import { S as SessionDigestResult, _ as DiscussionSearchResult, a as ExtractionPreparation, b as SessionDigestModelRoute, c as ExtractionResult, d as KnowledgeSave, f as KnowledgeSearch, g as DiscussionSearchRequest, h as ResearchTopicWrite, i as KnowledgeExportResult, l as KnowledgeCard, m as ResearchTopicSnapshot, n as ResearchReuseRecord, o as ExtractionPreparationRequest, p as ResearchTopic, r as KnowledgeExportRequest, s as ExtractionRequest, t as ResearchReusePreparation, u as KnowledgeMembership, v as SessionHistoryRequest, x as SessionDigestRequest, y as SessionHistoryResult } from "./research-reuse-3HT5WE0E.js";
+import { Context } from "@deepseek-ai/cordis";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import z from "@deepseek-ai/schemastery";
+import { z as z$1 } from "zod";
+import { Domain } from "@deepseek-ai/dsh-storage-domain";
+//#region src/session-digest-harness.d.ts
+/** Optional deployment fallback when an old or blank Session has no logged route. */
+interface SessionDigestRouteFallback extends SessionDigestModelRoute {}
+//#endregion
+//#region src/config.d.ts
+/** Optional auxiliary-model fallback and bounded output policy. */
+interface Config {
+  readonly provider?: string;
+  readonly model?: string;
+  readonly maxOutputTokens?: number;
+  readonly timeoutMs?: number;
+}
+interface ResolvedConfig {
+  readonly route?: SessionDigestRouteFallback;
+  readonly maxOutputTokens: number;
+  readonly timeoutMs: number;
+}
+/** Loader-facing runtime schema shared by direct callers and plugin activation. */
+declare const Config: z<Config>;
+/** Validate, default, and normalize configuration before runtime use. */
+declare function resolveConfig(config?: Config): ResolvedConfig;
+//#endregion
+//#region src/session-merge.d.ts
+/** Request submitted to the Host after the target is created and named. */
+interface SessionMergeSubmission {
+  readonly targetSessionId: string;
+  readonly sourceIds: readonly string[];
+  readonly instruction: string;
+  readonly operationId: string;
+}
+//#endregion
+//#region src/session-merge-projection.d.ts
+/** One immutable source snapshot captured for a Merge Session. */
+interface SessionMergeProjectionSource {
+  readonly sessionId: string;
+  readonly capturedThroughSeq: number | null;
+}
+/** Client-visible Merge Relation facts for one target Session. */
+interface SessionMergeProjection {
+  readonly operationId: string;
+  readonly contextEventSeq: number;
+  readonly sources: readonly SessionMergeProjectionSource[];
+}
+interface SessionMergeMarker {
+  readonly operationId: string;
+  readonly sourceIds: readonly string[];
+}
+/** Plain-JSON fold state persisted by the Harness Projection Cache. */
+interface SessionMergeProjectionState {
+  readonly inStep: boolean;
+  readonly marker: SessionMergeMarker | null;
+  readonly value: SessionMergeProjection | null;
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+  interface SessionProjectionStateMap {
+    sessionGraphMerge: SessionMergeProjectionState;
+  }
+  interface SessionProjectionMap {
+    /** Immutable provenance of an explicit Merge Session, or null until captured. */
+    sessionGraphMerge: SessionMergeProjection | null;
+  }
+}
+//#endregion
+//#region src/session-history-host.d.ts
+/** Public read-only Host boundary; Session Controller remains the source authority. */
+declare class SessionGraphHistoryService extends TypertRemoteService {
+  private readonly lifecycle;
+  private readonly activeReads;
+  private disposal;
+  constructor(ctx: Context);
+  read(request: SessionHistoryRequest, signal: AbortSignal): Promise<SessionHistoryResult>;
+  dispose(): Promise<void>;
+  private readHistory;
+}
+//#endregion
+//#region src/session-search-host.d.ts
+/** Host-owned search and source verification; queries never activate an Agent. */
+declare class SessionGraphSearchService extends TypertRemoteService {
+  private readonly snapshots;
+  private readonly lifecycle;
+  private readonly activeSearches;
+  private disposal;
+  constructor(ctx: Context);
+  search(request: DiscussionSearchRequest, signal: AbortSignal): Promise<DiscussionSearchResult>;
+  dispose(): Promise<void>;
+  private searchValidated;
+  private searchDiscussion;
+  private page;
+}
+//#endregion
+//#region src/research-topics-host.d.ts
+declare const RESEARCH_TOPIC_DOMAIN: {
+  readonly name: "session_graph_topics";
+  readonly version: 1;
+  readonly tables: {
+    readonly topics: {
+      readonly valueSchema: import("zod").ZodType<ResearchTopic, unknown, import("zod/v4/core").$ZodTypeInternals<ResearchTopic, unknown>>;
+    };
+  };
+};
+/** Durable topic operations use the Host's configured storage domain. */
+declare class ResearchTopicsService extends TypertRemoteService {
+  private readonly domain;
+  private readonly lifecycle;
+  private readonly active;
+  private tail;
+  private disposal;
+  constructor(ctx: Context, domain: Domain<typeof RESEARCH_TOPIC_DOMAIN>);
+  list(signal: AbortSignal): Promise<readonly ResearchTopic[]>;
+  read(request: {
+    readonly topicId: string;
+  }, signal: AbortSignal): Promise<ResearchTopicSnapshot>;
+  write(request: ResearchTopicWrite, signal: AbortSignal): Promise<ResearchTopic>;
+  private references;
+  private workspaceOwners;
+  dispose(): Promise<void>;
+  private run;
+}
+//#endregion
+//#region src/knowledge-host.d.ts
+declare const KNOWLEDGE_DOMAIN: {
+  readonly name: "session_graph_knowledge";
+  readonly version: 1;
+  readonly tables: {
+    readonly cards: {
+      readonly valueSchema: z$1.ZodType<KnowledgeCard, unknown, z$1.core.$ZodTypeInternals<KnowledgeCard, unknown>>;
+    };
+    readonly extraction_sources: {
+      readonly valueSchema: z$1.ZodType<ExtractionPreparation, unknown, z$1.core.$ZodTypeInternals<ExtractionPreparation, unknown>>;
+    };
+    readonly metadata: {
+      readonly valueSchema: z$1.ZodObject<{
+        hostId: z$1.ZodString;
+      }, z$1.core.$strip>;
+    };
+  };
+};
+/** Owns saved knowledge and explicit extraction; all source reads go through Harness. */
+declare class KnowledgeService extends TypertRemoteService {
+  private readonly domain;
+  private readonly config;
+  private readonly requests;
+  private tail;
+  constructor(ctx: Context, domain: Domain<typeof KNOWLEDGE_DOMAIN>, config: ResolvedConfig);
+  hostIdentity(signal: AbortSignal): Promise<{
+    readonly hostId: string;
+  }>;
+  prepareExport(request: KnowledgeExportRequest, signal: AbortSignal): Promise<KnowledgeExportResult>;
+  prepareExtraction(request: ExtractionPreparationRequest, signal: AbortSignal): Promise<ExtractionPreparation>;
+  extract(request: ExtractionRequest, signal: AbortSignal): Promise<ExtractionResult>;
+  private preparation;
+  private extractionSource;
+  read(request: {
+    readonly cardId: string;
+  }, signal: AbortSignal): Promise<KnowledgeCard | null>;
+  search(request: KnowledgeSearch, signal: AbortSignal): Promise<readonly KnowledgeCard[]>;
+  membership(request: KnowledgeMembership, signal: AbortSignal): Promise<KnowledgeCard>;
+  save(request: KnowledgeSave, signal: AbortSignal): Promise<KnowledgeCard>;
+  private capture;
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/research-reuse-host.d.ts
+declare const RESEARCH_REUSE_DOMAIN: {
+  readonly name: "session_graph_reuse";
+  readonly version: 1;
+  readonly tables: {
+    readonly attempts: {
+      readonly valueSchema: z$1.ZodType<ResearchReuseRecord, unknown, z$1.core.$ZodTypeInternals<ResearchReuseRecord, unknown>>;
+    };
+  };
+};
+/** A durable admission journal binds one frozen preview to one native Session/request identity. */
+declare class ResearchReuseService extends TypertRemoteService {
+  private readonly domain;
+  private readonly requests;
+  private tail;
+  constructor(ctx: Context, domain: Domain<typeof RESEARCH_REUSE_DOMAIN>);
+  prepare(request: ResearchReusePreparation, signal: AbortSignal): Promise<ResearchReuseRecord>;
+  read(request: {
+    readonly operationId: string;
+  }, signal: AbortSignal): Promise<ResearchReuseRecord | null>;
+  forSession(request: {
+    readonly sessionId: string;
+  }, signal: AbortSignal): Promise<readonly ResearchReuseRecord[]>;
+  submit(request: {
+    readonly operationId: string;
+  }, signal: AbortSignal): Promise<ResearchReuseRecord>;
+  private recoverTarget;
+  private serialize;
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/index.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    sessionGraphDigest: SessionGraphDigestService;
+    sessionGraphMerge: SessionGraphMergeService;
+    sessionGraphHistory: SessionGraphHistoryService;
+    sessionGraphSearch: SessionGraphSearchService;
+    sessionGraphTopics: ResearchTopicsService;
+    sessionGraphKnowledge: KnowledgeService;
+    sessionGraphReuse: ResearchReuseService;
+  }
+}
+/** Eager Host services required by the read-only digest capability. */
+declare const inject: string[];
+interface QuiescentRemoteService {
+  dispose(): Promise<void>;
+}
+/** Package-owned Host service addressed by the browser contribution. */
+declare class SessionGraphDigestService extends TypertRemoteService implements QuiescentRemoteService {
+  private readonly digests;
+  constructor(ctx: Context, config: ResolvedConfig);
+  generate(request: SessionDigestRequest, signal: AbortSignal): Promise<SessionDigestResult>;
+  dispose(): Promise<void>;
+}
+/** Package-owned Host service that submits one durable Session Merge capture. */
+declare class SessionGraphMergeService extends TypertRemoteService implements QuiescentRemoteService {
+  private readonly merges;
+  private readonly lifecycle;
+  private readonly activeCalls;
+  private disposed;
+  private disposal;
+  constructor(ctx: Context);
+  private disposedFailure;
+  private submitAdmitted;
+  submit(request: SessionMergeSubmission, callerSignal: AbortSignal): Promise<SessionMergeProjection>;
+  dispose(): Promise<void>;
+}
+/** Install read-only Search/History/Digest services, the Merge projection, and Merge submission. */
+declare function apply(ctx: Context, config?: Config): Promise<void>;
+//#endregion
+export { Config, SessionGraphDigestService, SessionGraphMergeService, apply, inject, resolveConfig };

package/lib/types/invariant.d.ts

@@ -0,0 +1,14 @@
+import { Context } from "@deepseek-ai/cordis";
+//#region src/invariant.d.ts
+/** Cordis companion plugin name. */
+declare const name = "research-graph-invariant";
+/** Service required before the companion can reserve package ownership. */
+declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+declare const apply: (ctx: Context) => Promise<() => void>;
+//#endregion
+export { apply, inject, name };