@longzai-intelligence-knowledge-graph/diagnosis 0.0.0-stage → 0.0.2

package/README.md

@@ -1,3 +1,11 @@
-# Temporary Holding Version
+# @longzai-intelligence-knowledge-graph/diagnosis
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Longzai Intelligence Knowledge Graph 的通用诊断引擎包，面向先修图提供自适应出题、判题与学习路径汇总的纯函数实现。
+
+## 简介
+
+引擎以先修有向无环图、知识点与题库为输入，按目标知识点展开先修子图并逐点出题。每个知识点最多两题，两题未过才沿先修边回溯且硬先修在前，一错一对记不稳不回溯，答对即推断全部祖先已掌握。出题由种子确定性驱动，同种子同作答必出同题。会话对象全程可 JSON 序列化，撤销、更正与刷新恢复一律经作答记录重放实现。
+
+## 用法
+
+从 `@longzai-intelligence-knowledge-graph/diagnosis` 导入 `createSession`、`nextQuestion`、`applyAnswer`、`replay` 与 `summarize`，配合 `DiagnosisGraph` 数据束驱动一次完整诊断，判题器结论可被调用方 `selfJudged` 裁定覆盖。包内不持有任何运行时状态，全部函数均为纯函数，邻接构建、稳定拓扑排序、祖先闭包与判题器等底层算法一并导出供复用。

package/dist/index.d.ts

@@ -0,0 +1,389 @@
+//#region src/types.d.ts
+/**
+ * 诊断引擎类型定义
+ *
+ * 会话对象全程可 JSON 序列化，刷新恢复、撤销与更正均由作答记录重放实现
+ */
+/**
+ * 知识点诊断状态
+ *
+ * @remarks
+ *   `mastered` 即直接答对判定，`mastered-inferred` 即由后代答对推断，
+ *   `shaky` 即一错一对，`weak` 即两题未过或单题即判，`pending` 即尚未判定
+ */
+type TopicStatus = 'mastered' | 'mastered-inferred' | 'shaky' | 'weak' | 'pending';
+/**
+ * 作答结果分类
+ *
+ * @remarks
+ *   `manual` 即判题器不下结论交学习者自评
+ */
+type JudgeResult = 'correct' | 'wrong' | 'manual';
+/**
+ * 引擎侧题目形态即数据束题目的最小消费面
+ */
+type EngineQuestion = {
+  id: string;
+  topicId: string;
+  difficulty: 'basic' | 'standard' | 'advanced';
+  type: 'choice' | 'short' | 'self';
+  prompt: string;
+  choices?: {
+    key: string;
+    text: string;
+  }[];
+  answer: string;
+  accept?: string[];
+};
+/**
+ * 引擎侧知识点形态
+ */
+type EngineTopic = {
+  id: string;
+  name: string;
+  stage: number;
+};
+/**
+ * 引擎侧先修边形态
+ */
+type EngineDependency = {
+  topicId: string;
+  prerequisiteId: string;
+  strength: 'hard' | 'soft';
+};
+/**
+ * 诊断图即引擎消费的先修有向无环图
+ */
+type DiagnosisGraph = {
+  topics: EngineTopic[];
+  dependencies: EngineDependency[];
+  questions: EngineQuestion[];
+};
+/**
+ * 单次作答记录
+ */
+type AnswerRecord = {
+  questionId: string;
+  topicId: string;
+  nth: number;
+  userAnswer: string;
+  result: Exclude<JudgeResult, 'manual'> | 'manual-correct' | 'manual-wrong';
+  judgedBy: 'auto' | 'self';
+};
+/**
+ * 诊断会话状态
+ *
+ * @remarks
+ *   全部字段可 JSON 序列化，`status` 以记录形态存各知识点状态
+ */
+type SessionState = {
+  seed: string;
+  targets: string[];
+  limit: number;
+  subgraph: string[];
+  status: Record<string, TopicStatus>;
+  stack: string[];
+  askedQuestionIds: string[];
+  answers: AnswerRecord[];
+  finished: boolean;
+  limitReached: boolean;
+  current: PendingQuestion | null;
+};
+/**
+ * 当前待答题目
+ */
+type PendingQuestion = {
+  question: EngineQuestion;
+  topicId: string;
+  nth: number;
+  reason: string;
+};
+/**
+ * 薄弱根因条目
+ */
+type WeakRoot = {
+  topicId: string;
+  reason: string;
+  untestedPrereqs: string[];
+};
+/**
+ * 学习路径条目
+ */
+type PathEntry = {
+  topicId: string;
+  status: TopicStatus;
+};
+/**
+ * 诊断结果汇总
+ */
+type DiagnosisSummary = {
+  targets: string[];
+  weakRoots: WeakRoot[];
+  shaky: string[];
+  path: PathEntry[];
+  masteredDirect: string[];
+  masteredInferred: string[];
+  weak: string[];
+  untested: string[];
+  limitReached: boolean;
+  retestPending: string[];
+};
+//#endregion
+//#region src/graph.utils.d.ts
+/**
+ * 邻接表即先修方向与被依赖方向
+ */
+type Adjacency = {
+  /**
+   * 知识点列表按入参顺序保留
+   */
+  topics: EngineTopic[];
+  /**
+   * id 到知识点的映射
+   */
+  byId: Map<string, EngineTopic>;
+  /**
+   * 先修邻接即 id 到直接先修边列表，硬边在前软边在后
+   */
+  pre: Map<string, EngineDependency[]>;
+  /**
+   * 被依赖邻接即 id 到直接依赖边列表
+   */
+  post: Map<string, EngineDependency[]>;
+  /**
+   * 知识点在 topics 中的序号即稳定排序基准
+   */
+  order: Map<string, number>;
+};
+/**
+ * 按阶段折叠的聚合节点
+ */
+type StageFoldGroup = {
+  /**
+   * 阶段序号
+   */
+  stage: number;
+  /**
+   * 成员 id 列表
+   */
+  members: string[];
+};
+/**
+ * 可达方向即先修方向或被依赖方向
+ */
+type ReachDirection = 'pre' | 'post';
+/**
+ * 构建邻接表
+ *
+ * @param graph - 诊断图
+ * @returns 邻接表
+ */
+declare function buildAdjacency(graph: DiagnosisGraph): Adjacency;
+/**
+ * 稳定拓扑排序
+ *
+ * @remarks
+ *   先修在前，同层按知识点在 topics 列表中的原始顺序排，保证结果可复现
+ * @param graph - 诊断图
+ * @returns 拓扑序的 id 列表
+ * @throws {@link Error} 图含环时抛出并列出环成员
+ */
+declare function topologicalSort(graph: DiagnosisGraph): string[];
+/**
+ * 祖先闭包即目标及其全部先修
+ *
+ * @param adjacency - 邻接表
+ * @param targets - 目标 id 列表
+ * @returns 闭包内 id 集合
+ */
+declare function ancestorClosure(adjacency: Adjacency, targets: string[]): Set<string>;
+/**
+ * 后代闭包即起点及其全部依赖者
+ *
+ * @param adjacency - 邻接表
+ * @param seeds - 起点 id 列表
+ * @returns 闭包内 id 集合
+ */
+declare function descendantClosure(adjacency: Adjacency, seeds: string[]): Set<string>;
+/**
+ * 深度限界的上游子图即向上指定层数的先修集合
+ *
+ * @param adjacency - 邻接表
+ * @param id - 中心知识点 id
+ * @param depth - 层数，传 `Infinity` 即全部祖先
+ * @returns 含中心点在内的 id 集合
+ */
+declare function upstreamWithin(adjacency: Adjacency, id: string, depth: number): Set<string>;
+/**
+ * 传递约简即子图内可删除的传递边集合
+ *
+ * @remarks
+ *   对每条边检查是否存在更长路径绕行，绕行可达即该边冗余，
+ *   结果供路径图省略中间点时保真呈现
+ * @param adjacency - 邻接表
+ * @param nodeSet - 子图 id 集合
+ * @returns 冗余边的 `先修>后继` 键集合
+ */
+declare function transitiveRedundancy(adjacency: Adjacency, nodeSet: Set<string>): Set<string>;
+/**
+ * 按阶段折叠祖先集合
+ *
+ * @remarks
+ *   中心点与其直接后代不参与折叠，其余祖先按阶段聚合成超节点
+ * @param adjacency - 邻接表
+ * @param nodeSet - 待折叠的 id 集合
+ * @param center - 中心点 id
+ * @returns 各阶段聚合组列表按阶段升序
+ */
+declare function foldByStage(adjacency: Adjacency, nodeSet: Set<string>, center: string): StageFoldGroup[];
+/**
+ * 可达计数即沿指定方向的全部可达节点数
+ *
+ * @param adjacency - 邻接表
+ * @param id - 起点
+ * @param direction - `pre` 即先修方向，`post` 即被依赖方向
+ * @returns 不含起点的可达数
+ */
+declare function reachCount(adjacency: Adjacency, id: string, direction: ReachDirection): number;
+//#endregion
+//#region src/judge.utils.d.ts
+/**
+ * 短答文本规范化
+ *
+ * @remarks
+ *   去全部空白、全角转半角、统一常见中文标点，保证书写差异不影响比对
+ * @param text - 原始作答文本
+ * @returns 规范化后文本
+ */
+declare function normalizeAnswer(text: string): string;
+/**
+ * 选择题选项键规范化
+ *
+ * @remarks
+ *   接受 `B`、`b`、`(B)`、`B.` 等常见写法，也接受与选项文本规范化后一致的全串
+ * @param input - 作答输入
+ * @param question - 题目
+ * @returns 命中的选项键，无法识别返回 `null`
+ */
+declare function matchChoiceKey(input: string, question: EngineQuestion): string | null;
+/**
+ * 判定一道题的作答
+ *
+ * @param question - 题目
+ * @param userAnswer - 学习者作答文本
+ * @returns `correct` 即判对，`wrong` 即判错，`manual` 即判题器不下结论须自评
+ */
+declare function judgeAnswer(question: EngineQuestion, userAnswer: string): JudgeResult;
+//#endregion
+//#region src/random.utils.d.ts
+/**
+ * 确定性伪随机源
+ *
+ * mulberry32 实现，同一随机种子产出完全一致的序列，保证同种子同作答即同出题
+ */
+/**
+ * 返回 `0` 到 `1` 区间随机数的生成函数
+ */
+type RandomSource = () => number;
+/**
+ * 由任意字符串派生 32 位随机种子
+ *
+ * @param text - 种子文本
+ * @returns 32 位无符号整数种子
+ */
+declare function hashSeed(text: string): number;
+/**
+ * mulberry32 随机数生成器
+ *
+ * @param seed - 32 位无符号整数种子
+ * @returns 随机数生成函数
+ */
+declare function mulberry32(seed: number): RandomSource;
+/**
+ * 由种子文本与命名空间派生的定点随机数
+ *
+ * @remarks
+ *   用于选题确定性，同一 `seed` 与 `scope` 永远返回同一个小数
+ * @param seed - 会话种子文本
+ * @param scope - 作用域文本如知识点加次序
+ * @returns `0` 到 `1` 区间随机数
+ */
+declare function scopedRandom(seed: string, scope: string): number;
+//#endregion
+//#region src/session.engine.d.ts
+/**
+ * 会话创建选项
+ */
+type SessionOptions = {
+  /**
+   * 题量上限按题计
+   *
+   * @default 16
+   */
+  limit?: number;
+  /**
+   * 选题随机种子文本
+   *
+   * @default 随机生成
+   */
+  seed?: string;
+  /**
+   * 历史已出题标识列表即跨会话避免重复出题
+   *
+   * @default 空列表
+   */
+  avoid?: string[];
+};
+/**
+ * 创建诊断会话
+ *
+ * @param graph - 诊断图
+ * @param targets - 目标知识点 id 列表
+ * @param options - 会话选项
+ * @returns 初始会话状态，先修子图已按稳定拓扑序展开
+ * @throws {@link Error} 诊断图含环时由拓扑排序抛出
+ */
+declare function createSession(graph: DiagnosisGraph, targets: string[], options?: SessionOptions): SessionState;
+/**
+ * 取当前待答题目
+ *
+ * @param graph - 诊断图
+ * @param session - 会话状态
+ * @param avoid - 历史已出题标识列表
+ * @returns 待答题目及其提问理由，会话结束或达题量上限时返回 `null`
+ */
+declare function nextQuestion(graph: DiagnosisGraph, session: SessionState, avoid?: string[]): SessionState['current'];
+/**
+ * 登记一次作答并推进状态
+ *
+ * @remarks
+ *   调用方给出 `selfJudged` 时以其为准即覆盖判题器结论，用于自评题与手动改判两种场景
+ * @param graph - 诊断图
+ * @param session - 会话状态
+ * @param userAnswer - 作答文本
+ * @param selfJudged - 学习者裁定的结论即自评或改判
+ */
+declare function applyAnswer(graph: DiagnosisGraph, session: SessionState, userAnswer: string, selfJudged?: 'correct' | 'wrong'): void;
+/**
+ * 由作答记录重放会话
+ *
+ * @remarks
+ *   刷新恢复、撤销与更正统一走本函数，保证状态与记录一致
+ * @param graph - 诊断图
+ * @param targets - 目标知识点 id 列表
+ * @param options - 会话选项
+ * @param answers - 作答记录列表
+ * @returns 重放后的会话状态
+ * @throws {@link Error} 诊断图含环时由会话创建抛出
+ */
+declare function replay(graph: DiagnosisGraph, targets: string[], options: SessionOptions, answers: AnswerRecord[]): SessionState;
+/**
+ * 汇总诊断结果
+ *
+ * @param graph - 诊断图
+ * @param session - 会话状态
+ * @returns 含薄弱根因、不稳清单、学习路径与掌握清单的汇总
+ */
+declare function summarize(graph: DiagnosisGraph, session: SessionState): DiagnosisSummary;
+//#endregion
+export { type Adjacency, type AnswerRecord, type DiagnosisGraph, type DiagnosisSummary, type EngineDependency, type EngineQuestion, type EngineTopic, type JudgeResult, type PathEntry, type PendingQuestion, type RandomSource, type ReachDirection, type SessionOptions, type SessionState, type StageFoldGroup, type TopicStatus, type WeakRoot, ancestorClosure, applyAnswer, buildAdjacency, createSession, descendantClosure, foldByStage, hashSeed, judgeAnswer, matchChoiceKey, mulberry32, nextQuestion, normalizeAnswer, reachCount, replay, scopedRandom, summarize, topologicalSort, transitiveRedundancy, upstreamWithin };

package/dist/index.js

@@ -0,0 +1 @@
+function e(e){let t=new Map(e.topics.map(e=>[e.id,e])),n=new Map(e.topics.map((e,t)=>[e.id,t])),r=/* @__PURE__ */ new Map,i=/* @__PURE__ */ new Map;for(let t of e.topics)r.set(t.id,[]),i.set(t.id,[]);for(let t of e.dependencies)r.get(t.topicId)?.push(t),i.get(t.prerequisiteId)?.push(t);for(let e of r.values())e.sort((e,t)=>e.strength===t.strength?0:e.strength===`hard`?-1:1);return{topics:e.topics,byId:t,pre:r,post:i,order:n}}function t(t){let n=e(t),r=/* @__PURE__ */ new Map;for(let e of t.topics)r.set(e.id,n.pre.get(e.id)?.length??0);let i=t.topics.filter(e=>(r.get(e.id)??0)===0).map(e=>e.id),a=[];for(;i.length>0;){let e=i.shift();if(e===void 0)break;a.push(e);for(let t of n.post.get(e)??[]){let e=(r.get(t.topicId)??0)-1;r.set(t.topicId,e),e===0&&i.push(t.topicId)}}if(a.length!==t.topics.length){let e=t.topics.filter(e=>!a.includes(e.id)).map(e=>e.id);throw Error(`图含环，环成员即 ${e.join(`、`)}`)}return a}function n(e,t){let n=/* @__PURE__ */ new Set,r=t=>{if(!n.has(t)){n.add(t);for(let n of e.pre.get(t)??[])r(n.prerequisiteId)}};for(let e of t)r(e);return n}function r(e,t){let n=/* @__PURE__ */ new Set,r=t=>{if(!n.has(t)){n.add(t);for(let n of e.post.get(t)??[])r(n.topicId)}};for(let e of t)r(e);return n}function i(e,t,n){let r=/* @__PURE__ */ new Set([t]),i=[t],a=n===1/0?2**53-1:n;for(let t=0;t<a;t+=1){let t=[];for(let n of i)for(let i of e.pre.get(n)??[])r.has(i.prerequisiteId)||(r.add(i.prerequisiteId),t.push(i.prerequisiteId));if(t.length===0)break;i=t}return r}function a(e,t){let n=/* @__PURE__ */ new Set,r=[];for(let n of e.topics)for(let i of e.pre.get(n.id)??[])t.has(i.topicId)&&t.has(i.prerequisiteId)&&r.push(i);for(let i of r){let r=`${i.prerequisiteId}>${i.topicId}`;if(n.has(r))continue;let a=/* @__PURE__ */ new Set,o=n=>{for(let r of e.pre.get(n)??[])t.has(r.prerequisiteId)&&(n!==i.topicId||r.prerequisiteId!==i.prerequisiteId)&&(a.has(r.prerequisiteId)||(a.add(r.prerequisiteId),o(r.prerequisiteId)))};o(i.topicId),a.has(i.prerequisiteId)&&n.add(r)}return n}function o(e,t,n){let r=new Set((e.post.get(n)??[]).map(e=>e.topicId)),i=/* @__PURE__ */ new Map;for(let a of t){if(a===n||r.has(a))continue;let t=e.byId.get(a)?.stage??0,o=i.get(t)??[];o.push(a),i.set(t,o)}return[...i.entries()].map(([e,t])=>({stage:e,members:t})).sort((e,t)=>e.stage-t.stage)}function s(e,t,n){let r=/* @__PURE__ */ new Set,i=t=>{for(let a of e[n].get(t)??[]){let e=n===`pre`?a.prerequisiteId:a.topicId;r.has(e)||(r.add(e),i(e))}};return i(t),r.size}function c(e){return e.normalize(`NFKC`).replace(/\s+/g,``).replace(/、/g,`,`).replace(/。/g,``).replace(/，/g,`,`).replace(/：/g,`:`).toLowerCase()}function l(e,t){let n=c(e),r=/^[(（]?([abcd])[).．]?$/.exec(n)?.[1];if(r)return r.toUpperCase();for(let e of t.choices??[])if(c(e.text)===n)return e.key;return null}function u(e,t){if(e.type===`self`)return`manual`;if(e.type===`choice`){let n=l(t,e);return n===null?`manual`:n===e.answer?`correct`:`wrong`}let n=c(t);if(n===``)return`manual`;let r=[e.answer,...e.accept??[]];for(let e of r)if(c(e)===n)return`correct`;return e.answer.length<=24?`wrong`:`manual`}function d(e){let t=2166136261;for(let n=0;n<e.length;n+=1)t^=e.charCodeAt(n),t=Math.imul(t,16777619);return t>>>0}function f(e){let t=e>>>0;return()=>{t=t+1831565813>>>0;let e=t;return e=Math.imul(e^e>>>15,e|1),e^=e+Math.imul(e^e>>>7,e|61),((e^e>>>14)>>>0)/4294967296}}function p(e,t){return f(d(`${e}|${t}`))()}const m={basic:0,standard:1,advanced:2};function h(r,i,a={}){let o=n(e(r),i),s=t(r).filter(e=>o.has(e)),c={};for(let e of s)c[e]=`pending`;let l=i.filter(e=>o.has(e)),u=new Map(s.map((e,t)=>[e,t])),d=[...l].sort((e,t)=>(u.get(e)??0)-(u.get(t)??0));return{seed:a.seed??`auto-${Date.now()}-${Math.floor(Math.random()*1e6)}`,targets:l,limit:a.limit??16,subgraph:s,status:c,stack:d,askedQuestionIds:[],answers:[],finished:l.length===0,limitReached:!1,current:null}}function g(e,t,n,r){return p(e.seed,`${t}|${n}|${r.id}`)}function _(e,t,n,r){if(r.length===0)return null;let i=r[0];if(!i)return null;for(let a of r)g(e,t,n,a)<g(e,t,n,i)&&(i=a);return i}function v(e,t,n,r,i){let a=e.questions.filter(e=>e.topicId===n&&!t.askedQuestionIds.includes(e.id));if(a.length===0)return null;let o=a.filter(e=>!i.includes(e.id)),s=o.length>0?o:a;if(r===1){let e=s.filter(e=>e.difficulty!==`advanced`);return _(t,n,r,e.length>0?e:s)}let c=t.answers.find(e=>e.topicId===n&&e.nth===1),l=e.questions.find(e=>e.id===c?.questionId),u=m[l?.difficulty??`standard`],d=[[],[],[]];for(let e of a)d[m[e.difficulty]]?.push(e);let f=[0,u,...[0,1,2].filter(e=>e<u),...[0,1,2].filter(e=>e>u)],p=[...new Set(f)];for(let e of p){let i=d[e],a=i?_(t,n,r,i):null;if(a)return a}return null}function y(e,t,n=[]){if(t.finished||t.current)return t.current;if(t.askedQuestionIds.length>=t.limit)return t.limitReached=!0,t.finished=!0,null;for(;t.stack.length>0;){let r=t.stack.at(-1);if(r===void 0)break;if(t.status[r]!==`pending`){t.stack.pop();continue}let i=t.answers.filter(e=>e.topicId===r).length+1===1?1:2,a=v(e,t,r,i,n);if(!a){t.stack.pop();continue}let o=t.targets.includes(r);return t.current={question:a,topicId:r,nth:i,reason:o?`目标本身`:i===2?`同一知识点的复测`:!o&&i===1?`因后继知识点两题未过而回溯`:`目标链上的知识点`},t.current}return t.finished=!0,null}function b(t,r,i,a){let o=r.current;if(!o)return;let s=u(o.question,i),c=a??(s===`manual`?`manual`:s);if(c===`manual`)return;let l={questionId:o.question.id,topicId:o.topicId,nth:o.nth,userAnswer:i,result:a?a===`correct`?`manual-correct`:`manual-wrong`:c,judgedBy:a?`self`:`auto`};r.answers.push(l),r.askedQuestionIds.push(o.question.id),r.current=null;let d=e(t),f=c===`correct`;if(o.nth===1&&f){r.status[o.topicId]=`mastered`;for(let e of n(d,[o.topicId]))r.status[e]===`pending`&&(r.status[e]=`mastered-inferred`)}else if(o.nth===1&&!f)r.stack.push(o.topicId);else if(o.nth===2&&!f){r.status[o.topicId]=`weak`;let e=(d.pre.get(o.topicId)??[]).filter(e=>r.subgraph.includes(e.prerequisiteId)&&r.status[e.prerequisiteId]===`pending`);for(let t=e.length-1;t>=0;--t){let n=e[t];n&&r.stack.push(n.prerequisiteId)}}else r.status[o.topicId]=`shaky`;r.askedQuestionIds.length>=r.limit&&(r.limitReached=!0,r.finished=!0)}function x(e,t,n,r){let i=h(e,t,n);for(let t of r){let r=y(e,i,n.avoid??[]);if(!r||r.question.id!==t.questionId)break;let a=t.result===`correct`||t.result===`manual-correct`?`correct`:`wrong`;b(e,i,t.userAnswer,a)}return i}function S(t,n){let i=e(t),a=[],o=[],s=[],c=[],l=[],u=[],d=new Set(n.answers.map(e=>e.topicId));for(let e of n.subgraph){let t=n.status[e];if(t===`weak`)a.push(e);else if(t===`shaky`)s.push(e);else if(t===`mastered`)c.push(e);else if(t===`mastered-inferred`)l.push(e);else if(u.push(e),d.has(e)){let t=n.answers.filter(t=>t.topicId===e),r=t[0];t.length===1&&r&&r.result!==`correct`&&r.result!==`manual-correct`&&(a.push(e),o.push(e))}}let f=new Set(a),p=a.map(e=>({topicId:e,reason:`两题未过且其直接先修未发现薄弱，推断薄弱从这里开始`,untestedPrereqs:(i.pre.get(e)??[]).filter(e=>n.status[e.prerequisiteId]===`pending`).map(e=>e.prerequisiteId)})).filter(e=>!(i.pre.get(e.topicId)??[]).some(e=>f.has(e.prerequisiteId))),m=r(i,[...p.map(e=>e.topicId),...s]),h=/* @__PURE__ */ new Set([...c,...l]),g=new Map(n.subgraph.map((e,t)=>[e,t])),_=n.subgraph.filter(e=>m.has(e)&&!h.has(e)).map(e=>({topicId:e,status:n.status[e]??`pending`})).sort((e,t)=>(i.byId.get(e.topicId)?.stage??0)-(i.byId.get(t.topicId)?.stage??0)||(g.get(e.topicId)??0)-(g.get(t.topicId)??0));return{targets:n.targets,weakRoots:p,shaky:s,path:_,masteredDirect:c,masteredInferred:l,weak:a,untested:u.filter(e=>!o.includes(e)),limitReached:n.limitReached,retestPending:o}}export{n as ancestorClosure,b as applyAnswer,e as buildAdjacency,h as createSession,r as descendantClosure,o as foldByStage,d as hashSeed,u as judgeAnswer,l as matchChoiceKey,f as mulberry32,y as nextQuestion,c as normalizeAnswer,s as reachCount,x as replay,p as scopedRandom,S as summarize,t as topologicalSort,a as transitiveRedundancy,i as upstreamWithin};

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@longzai-intelligence-knowledge-graph/diagnosis",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "description": "知识图谱先修图通用诊断引擎即自适应出题、判题与学习路径汇总的纯函数包",
+  "keywords": [
+    "diagnosis",
+    "engine",
+    "knowledge-graph",
+    "longzai-intelligence",
+    "prerequisite-graph"
+  ],
+  "license": "UNLICENSED",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "lzi-builder",
+    "build:prod": "NODE_ENV=production bun run build",
+    "prepublishOnly": "bun run build:prod",
+    "typecheck": "bun run typecheck:app && bun run typecheck:node && bun run typecheck:test",
+    "typecheck:app": "lzi-tsgo typecheck tsconfig/app.json",
+    "typecheck:node": "lzi-tsgo typecheck tsconfig/node.json",
+    "typecheck:test": "lzi-tsgo typecheck tsconfig/test.json",
+    "lint": "oxlint && oxfmt --check",
+    "lint:fix": "oxlint --fix && oxfmt",
+    "test": "lzi-bun-cli test",
+    "test:watch": "lzi-bun-cli test --watch",
+    "test:coverage": "lzi-bun-cli test --coverage",
+    "clean": "lzi-dev-cli clean"
+  }
+}