@vue-skuilder/db 0.2.27 → 0.2.28
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/classroomDB-DLTtLZct.d.cts +86 -0
- package/dist/classroomDB-DLTtLZct.d.ts +86 -0
- package/dist/{contentSource-LPf044hY.d.ts → contentSource-BoFBwvYa.d.ts} +65 -98
- package/dist/{contentSource-D3c1fMAk.d.cts → contentSource-DpQqTG3m.d.cts} +65 -98
- package/dist/core/index.d.cts +6 -5
- package/dist/core/index.d.ts +6 -5
- package/dist/core/index.js +22 -2
- package/dist/core/index.js.map +1 -1
- package/dist/core/index.mjs +22 -2
- package/dist/core/index.mjs.map +1 -1
- package/dist/{dataLayerProvider-DaAootVV.d.ts → dataLayerProvider-D_LJT3F4.d.ts} +2 -8
- package/dist/{dataLayerProvider-CeLiFbHv.d.cts → dataLayerProvider-Dl3cAAvQ.d.cts} +2 -8
- package/dist/diagnostics/index.d.cts +370 -0
- package/dist/diagnostics/index.d.ts +370 -0
- package/dist/diagnostics/index.js +778 -0
- package/dist/diagnostics/index.js.map +1 -0
- package/dist/diagnostics/index.mjs +729 -0
- package/dist/diagnostics/index.mjs.map +1 -0
- package/dist/impl/couch/index.d.cts +4 -3
- package/dist/impl/couch/index.d.ts +4 -3
- package/dist/impl/couch/index.js +22 -2
- package/dist/impl/couch/index.js.map +1 -1
- package/dist/impl/couch/index.mjs +22 -2
- package/dist/impl/couch/index.mjs.map +1 -1
- package/dist/impl/static/index.d.cts +5 -5
- package/dist/impl/static/index.d.ts +5 -5
- package/dist/impl/static/index.js +22 -8
- package/dist/impl/static/index.js.map +1 -1
- package/dist/impl/static/index.mjs +22 -8
- package/dist/impl/static/index.mjs.map +1 -1
- package/dist/{index-BkBJlGDX.d.ts → index-CVGehe_t.d.ts} +1 -1
- package/dist/{index-D7WdMDAs.d.cts → index-Ktg72jKb.d.cts} +1 -1
- package/dist/index.d.cts +10 -9
- package/dist/index.d.ts +10 -9
- package/dist/index.js +64 -23
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +64 -23
- package/dist/index.mjs.map +1 -1
- package/dist/{types-DjiFOZxJ.d.cts → types-D0oQeJAi.d.cts} +1 -1
- package/dist/{types-uJ2Xn3_X.d.ts → types-dXWfyz9B.d.ts} +1 -1
- package/dist/{types-legacy-CrwyZIvI.d.cts → types-legacy-BkOYOR6U.d.cts} +1 -1
- package/dist/{types-legacy-CrwyZIvI.d.ts → types-legacy-BkOYOR6U.d.ts} +1 -1
- package/dist/util/packer/index.d.cts +3 -3
- package/dist/util/packer/index.d.ts +3 -3
- package/package.json +15 -3
- package/src/core/interfaces/dataLayerProvider.ts +3 -8
- package/src/core/navigators/Pipeline.ts +5 -2
- package/src/core/navigators/PipelineDebugger.ts +64 -16
- package/src/core/navigators/index.ts +1 -0
- package/src/core/types/studySession.ts +37 -0
- package/src/diagnostics/dataset.ts +231 -0
- package/src/diagnostics/derive.ts +555 -0
- package/src/diagnostics/index.ts +24 -0
- package/src/diagnostics/loader.ts +191 -0
- package/src/diagnostics/text.ts +242 -0
- package/src/impl/couch/PouchDataLayerProvider.ts +0 -23
- package/src/impl/static/StaticDataLayerProvider.ts +0 -11
- package/src/study/SessionController.ts +56 -2
- package/tsup.config.ts +1 -0
|
@@ -0,0 +1,729 @@
|
|
|
1
|
+
// src/diagnostics/dataset.ts
|
|
2
|
+
var PREFIX = {
|
|
3
|
+
cardHistory: "cardH",
|
|
4
|
+
scheduled: "card_review_",
|
|
5
|
+
session: "SESSION::",
|
|
6
|
+
strategyState: "STRATEGY_STATE::",
|
|
7
|
+
registrations: "CourseRegistrations"
|
|
8
|
+
};
|
|
9
|
+
function toIsoTimestamp(value) {
|
|
10
|
+
if (typeof value === "number") return new Date(value).toISOString();
|
|
11
|
+
const s = String(value ?? "");
|
|
12
|
+
const ms = Date.parse(s);
|
|
13
|
+
return Number.isNaN(ms) ? s : new Date(ms).toISOString();
|
|
14
|
+
}
|
|
15
|
+
function dumpFileName(dump) {
|
|
16
|
+
return `userdb-${dump.username}-${dump.fetchedAt.slice(0, 16).replace(":", "")}Z.json`;
|
|
17
|
+
}
|
|
18
|
+
function parseLearnerDump(text) {
|
|
19
|
+
const dump = JSON.parse(text);
|
|
20
|
+
if (!dump || typeof dump.username !== "string" || !Array.isArray(dump.docs)) {
|
|
21
|
+
throw new Error("[diagnostics] Not a learner dump: expected `username` and a `docs` array");
|
|
22
|
+
}
|
|
23
|
+
return dump;
|
|
24
|
+
}
|
|
25
|
+
function questionTypeOf(idView) {
|
|
26
|
+
if (typeof idView !== "string") return void 0;
|
|
27
|
+
const parts = idView.split(".");
|
|
28
|
+
return parts.length >= 2 ? parts[parts.length - 2] : idView;
|
|
29
|
+
}
|
|
30
|
+
function summarizeCards(slice) {
|
|
31
|
+
const data = new Map(slice.displayableData.map((dd) => [dd._id, dd]));
|
|
32
|
+
const cards = /* @__PURE__ */ new Map();
|
|
33
|
+
for (const card of slice.cards) {
|
|
34
|
+
const fields = {};
|
|
35
|
+
for (const f of data.get(card.id_displayable_data?.[0] ?? "")?.data ?? []) {
|
|
36
|
+
fields[f.name] = f.data;
|
|
37
|
+
}
|
|
38
|
+
cards.set(card._id, {
|
|
39
|
+
cardId: card._id,
|
|
40
|
+
questionType: questionTypeOf(card.id_view),
|
|
41
|
+
elo: card.elo,
|
|
42
|
+
tags: [],
|
|
43
|
+
data: fields
|
|
44
|
+
});
|
|
45
|
+
}
|
|
46
|
+
for (const tag of slice.tags) {
|
|
47
|
+
for (const cardId of tag.taggedCards ?? []) cards.get(cardId)?.tags.push(tag.name);
|
|
48
|
+
}
|
|
49
|
+
return cards;
|
|
50
|
+
}
|
|
51
|
+
function inferCourseId(dump) {
|
|
52
|
+
if (dump.courseId) return dump.courseId;
|
|
53
|
+
if (dump.course) return dump.course.courseId;
|
|
54
|
+
const counts = /* @__PURE__ */ new Map();
|
|
55
|
+
for (const d of dump.docs) {
|
|
56
|
+
if (d._id.startsWith(PREFIX.session) && typeof d.courseId === "string") {
|
|
57
|
+
counts.set(d.courseId, (counts.get(d.courseId) ?? 0) + 1);
|
|
58
|
+
}
|
|
59
|
+
}
|
|
60
|
+
return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
|
|
61
|
+
}
|
|
62
|
+
function fromDump(dump, courseId) {
|
|
63
|
+
const course = courseId ?? inferCourseId(dump);
|
|
64
|
+
if (!course) throw new Error("[diagnostics] No course id given, and none found in the dump");
|
|
65
|
+
const sessions = [];
|
|
66
|
+
const cardHistories = [];
|
|
67
|
+
const scheduled = [];
|
|
68
|
+
const strategyState = {};
|
|
69
|
+
let registration;
|
|
70
|
+
for (const doc of dump.docs) {
|
|
71
|
+
const id = doc._id;
|
|
72
|
+
if (id.startsWith(PREFIX.session)) {
|
|
73
|
+
if (doc.courseId === course) sessions.push(doc);
|
|
74
|
+
} else if (id.startsWith(PREFIX.cardHistory)) {
|
|
75
|
+
if (doc.courseID !== course) continue;
|
|
76
|
+
const history = doc;
|
|
77
|
+
cardHistories.push({
|
|
78
|
+
...history,
|
|
79
|
+
records: (history.records ?? []).map((r) => ({ ...r, timeStamp: toIsoTimestamp(r.timeStamp) })).sort((a, b) => a.timeStamp.localeCompare(b.timeStamp))
|
|
80
|
+
});
|
|
81
|
+
} else if (id.startsWith(PREFIX.scheduled)) {
|
|
82
|
+
if (doc.courseId === course) scheduled.push(doc);
|
|
83
|
+
} else if (id.startsWith(PREFIX.strategyState)) {
|
|
84
|
+
const [, docCourse, key] = id.split("::");
|
|
85
|
+
if (docCourse === course && key) strategyState[key] = doc.data;
|
|
86
|
+
} else if (id === PREFIX.registrations) {
|
|
87
|
+
registration = doc;
|
|
88
|
+
}
|
|
89
|
+
}
|
|
90
|
+
sessions.sort((a, b) => a.startTime.localeCompare(b.startTime));
|
|
91
|
+
scheduled.sort((a, b) => String(a.reviewTime).localeCompare(String(b.reviewTime)));
|
|
92
|
+
return {
|
|
93
|
+
username: dump.username,
|
|
94
|
+
courseId: course,
|
|
95
|
+
asOf: dump.fetchedAt,
|
|
96
|
+
sessions,
|
|
97
|
+
cardHistories,
|
|
98
|
+
scheduled,
|
|
99
|
+
registration,
|
|
100
|
+
strategyState,
|
|
101
|
+
tombstones: (dump.tombstones ?? []).map(({ id, seq }) => ({ id, seq })),
|
|
102
|
+
...dump.course && dump.course.courseId === course ? { cards: summarizeCards(dump.course) } : {}
|
|
103
|
+
};
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
// src/diagnostics/loader.ts
|
|
107
|
+
function userDbName(username) {
|
|
108
|
+
let hex = "";
|
|
109
|
+
for (const b of new TextEncoder().encode(username)) hex += b.toString(16).padStart(2, "0");
|
|
110
|
+
return "userdb-" + hex;
|
|
111
|
+
}
|
|
112
|
+
function base64(s) {
|
|
113
|
+
let binary = "";
|
|
114
|
+
for (const b of new TextEncoder().encode(s)) binary += String.fromCharCode(b);
|
|
115
|
+
return btoa(binary);
|
|
116
|
+
}
|
|
117
|
+
function trimTrailingSlashes(url) {
|
|
118
|
+
let end = url.length;
|
|
119
|
+
while (end > 0 && url[end - 1] === "/") end--;
|
|
120
|
+
return url.slice(0, end);
|
|
121
|
+
}
|
|
122
|
+
function couchReader(opts) {
|
|
123
|
+
const doFetch = opts.fetchImpl ?? fetch;
|
|
124
|
+
const base = trimTrailingSlashes(opts.couchUrl);
|
|
125
|
+
const headers = { Accept: "application/json" };
|
|
126
|
+
if (opts.auth.kind === "basic") {
|
|
127
|
+
headers.Authorization = "Basic " + base64(`${opts.auth.username}:${opts.auth.password}`);
|
|
128
|
+
}
|
|
129
|
+
const credentials = opts.auth.kind === "cookie" ? "include" : void 0;
|
|
130
|
+
async function get(path, init = {}) {
|
|
131
|
+
const res = await doFetch(`${base}/${path}`, {
|
|
132
|
+
method: init.method ?? "GET",
|
|
133
|
+
headers: init.body ? { ...headers, "Content-Type": "application/json" } : headers,
|
|
134
|
+
...init.body ? { body: JSON.stringify(init.body) } : {},
|
|
135
|
+
...credentials ? { credentials } : {}
|
|
136
|
+
});
|
|
137
|
+
if (!res.ok) {
|
|
138
|
+
const detail = await res.text().catch(() => "");
|
|
139
|
+
throw new Error(`[diagnostics] ${init.method ?? "GET"} ${path} -> ${res.status} ${detail}`);
|
|
140
|
+
}
|
|
141
|
+
return await res.json();
|
|
142
|
+
}
|
|
143
|
+
async function byKeys(db, keys) {
|
|
144
|
+
const out = [];
|
|
145
|
+
const CHUNK = 500;
|
|
146
|
+
for (let i = 0; i < keys.length; i += CHUNK) {
|
|
147
|
+
const body = await get(
|
|
148
|
+
`${db}/_all_docs?include_docs=true`,
|
|
149
|
+
{ method: "POST", body: { keys: keys.slice(i, i + CHUNK) } }
|
|
150
|
+
);
|
|
151
|
+
for (const row of body.rows) if (row.doc) out.push(row.doc);
|
|
152
|
+
}
|
|
153
|
+
return out;
|
|
154
|
+
}
|
|
155
|
+
async function byPrefix(db, prefix) {
|
|
156
|
+
const q = new URLSearchParams({
|
|
157
|
+
include_docs: "true",
|
|
158
|
+
startkey: JSON.stringify(prefix),
|
|
159
|
+
endkey: JSON.stringify(prefix + "\uFFF0")
|
|
160
|
+
});
|
|
161
|
+
const body = await get(`${db}/_all_docs?${q}`);
|
|
162
|
+
return body.rows.map((r) => r.doc).filter((d) => !!d);
|
|
163
|
+
}
|
|
164
|
+
return { base, get, byKeys, byPrefix };
|
|
165
|
+
}
|
|
166
|
+
function touchedCardIds(docs) {
|
|
167
|
+
const ids = /* @__PURE__ */ new Set();
|
|
168
|
+
for (const d of docs) {
|
|
169
|
+
if (d._id.startsWith("cardH") && typeof d.cardID === "string") ids.add(d.cardID);
|
|
170
|
+
else if (d._id.startsWith("card_review_") && typeof d.cardId === "string") ids.add(d.cardId);
|
|
171
|
+
else if (d._id.startsWith("SESSION::") && Array.isArray(d.eloEvents)) {
|
|
172
|
+
for (const e of d.eloEvents) if (e.cardId) ids.add(e.cardId);
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
return [...ids];
|
|
176
|
+
}
|
|
177
|
+
async function fetchLearnerDump(opts) {
|
|
178
|
+
const couch = couchReader(opts);
|
|
179
|
+
const dbName = userDbName(opts.username);
|
|
180
|
+
const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
|
|
181
|
+
const info = await couch.get(dbName);
|
|
182
|
+
const q = new URLSearchParams({ include_docs: "true" });
|
|
183
|
+
if (opts.attachments) q.set("attachments", "true");
|
|
184
|
+
const all = await couch.get(`${dbName}/_all_docs?${q}`);
|
|
185
|
+
const docs = all.rows.map((r) => r.doc).filter((d) => !!d);
|
|
186
|
+
const changes = await couch.get(`${dbName}/_changes?style=main_only`);
|
|
187
|
+
const tombstones = changes.results.filter((c) => c.deleted).map((c) => ({ id: c.id, rev: c.changes[0]?.rev, seq: Number(String(c.seq).split("-")[0]) }));
|
|
188
|
+
const scope = opts.cards ?? "touched";
|
|
189
|
+
let course;
|
|
190
|
+
if (scope !== "none") {
|
|
191
|
+
const courseDb = `coursedb-${opts.courseId}`;
|
|
192
|
+
let cards;
|
|
193
|
+
if (scope === "all") {
|
|
194
|
+
const found = await couch.get(`${courseDb}/_find`, {
|
|
195
|
+
method: "POST",
|
|
196
|
+
body: { selector: { docType: "CARD" }, limit: 1e6 }
|
|
197
|
+
});
|
|
198
|
+
cards = found.docs;
|
|
199
|
+
} else {
|
|
200
|
+
cards = await couch.byKeys(courseDb, touchedCardIds(docs));
|
|
201
|
+
}
|
|
202
|
+
const cardIds = new Set(cards.map((c) => c._id));
|
|
203
|
+
const ddIds = /* @__PURE__ */ new Set();
|
|
204
|
+
for (const c of cards) {
|
|
205
|
+
for (const id of c.id_displayable_data ?? []) ddIds.add(id);
|
|
206
|
+
}
|
|
207
|
+
const displayableData = await couch.byKeys(courseDb, [...ddIds]);
|
|
208
|
+
const tags = (await couch.byPrefix(courseDb, "TAG")).map((t) => {
|
|
209
|
+
const tagged = Array.isArray(t.taggedCards) ? t.taggedCards : [];
|
|
210
|
+
return {
|
|
211
|
+
...t,
|
|
212
|
+
taggedCount: tagged.length,
|
|
213
|
+
taggedCards: scope === "all" ? tagged : tagged.filter((id) => cardIds.has(id))
|
|
214
|
+
};
|
|
215
|
+
}).filter((t) => scope === "all" || t.taggedCards.length > 0);
|
|
216
|
+
course = {
|
|
217
|
+
courseId: opts.courseId,
|
|
218
|
+
source: `${couch.base}/${courseDb}`,
|
|
219
|
+
scope,
|
|
220
|
+
cards,
|
|
221
|
+
displayableData,
|
|
222
|
+
tags
|
|
223
|
+
};
|
|
224
|
+
}
|
|
225
|
+
return {
|
|
226
|
+
formatVersion: 1,
|
|
227
|
+
username: opts.username,
|
|
228
|
+
dbName,
|
|
229
|
+
source: couch.base,
|
|
230
|
+
fetchedAt,
|
|
231
|
+
courseId: opts.courseId,
|
|
232
|
+
info,
|
|
233
|
+
docs,
|
|
234
|
+
tombstones,
|
|
235
|
+
...course ? { course } : {}
|
|
236
|
+
};
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
// src/diagnostics/derive.ts
|
|
240
|
+
var isSkillTag = (i, tag) => i?.isSkillTag?.(tag) ?? false;
|
|
241
|
+
var shortTag = (i, tag) => i?.shortTag?.(tag) ?? tag;
|
|
242
|
+
function bySkillThenName(i) {
|
|
243
|
+
return (a, b) => {
|
|
244
|
+
const d = Number(isSkillTag(i, b)) - Number(isSkillTag(i, a));
|
|
245
|
+
return d !== 0 ? d : a.localeCompare(b);
|
|
246
|
+
};
|
|
247
|
+
}
|
|
248
|
+
function defaultSnapshotMetrics(snapshot) {
|
|
249
|
+
const out = {};
|
|
250
|
+
for (const [k, v] of Object.entries(snapshot)) {
|
|
251
|
+
if (typeof v === "number") out[k] = v;
|
|
252
|
+
else if (v && typeof v === "object" && !Array.isArray(v)) {
|
|
253
|
+
for (const [k2, v2] of Object.entries(v)) {
|
|
254
|
+
if (typeof v2 === "number") out[`${k}.${k2}`] = v2;
|
|
255
|
+
}
|
|
256
|
+
}
|
|
257
|
+
}
|
|
258
|
+
return out;
|
|
259
|
+
}
|
|
260
|
+
var SESSION_FLAGS = {
|
|
261
|
+
churned: {
|
|
262
|
+
label: "Churned",
|
|
263
|
+
help: "Many pipeline runs relative to cards served: the plan kept being rebuilt rather than consumed."
|
|
264
|
+
},
|
|
265
|
+
"out-of-content": {
|
|
266
|
+
label: "Out of content",
|
|
267
|
+
help: "Ended with time left on the clock: content ran out before the session did."
|
|
268
|
+
},
|
|
269
|
+
walked: {
|
|
270
|
+
label: "Walked",
|
|
271
|
+
help: "Abandoned or never closed, after real time invested. Not a mis-click."
|
|
272
|
+
},
|
|
273
|
+
stalled: {
|
|
274
|
+
label: "Stalled",
|
|
275
|
+
help: "No progress metric moved and ELO was essentially flat. The sitting produced nothing measurable."
|
|
276
|
+
},
|
|
277
|
+
grinding: {
|
|
278
|
+
label: "Grinding",
|
|
279
|
+
help: "Majority-incorrect, or ended with unfinished cards still in the failed queue."
|
|
280
|
+
}
|
|
281
|
+
};
|
|
282
|
+
var SESSION_FLAG_THRESHOLDS = {
|
|
283
|
+
/** Runs per card above which a session counts as churned. */
|
|
284
|
+
churnRunsPerCard: 1 / 3,
|
|
285
|
+
/** Minimum cards before churn is meaningful. */
|
|
286
|
+
churnMinCards: 4,
|
|
287
|
+
/** Leftover clock (s) that counts as running out of content. */
|
|
288
|
+
outOfContentSeconds: 20,
|
|
289
|
+
/** Cards below which an abandon reads as a mis-click, not a walk-out. */
|
|
290
|
+
walkMinCards: 2,
|
|
291
|
+
/** |ELO change| below which movement is flat. */
|
|
292
|
+
stallEloEpsilon: 5,
|
|
293
|
+
/** Accuracy below which a session is grinding. */
|
|
294
|
+
grindAccuracy: 0.5
|
|
295
|
+
};
|
|
296
|
+
function stateRows(doc, interp) {
|
|
297
|
+
const read = interp?.snapshotMetrics ?? defaultSnapshotMetrics;
|
|
298
|
+
const a = doc.stateAtStart ? read(doc.stateAtStart) : {};
|
|
299
|
+
const b = doc.stateAtEnd ? read(doc.stateAtEnd) : {};
|
|
300
|
+
const labels = [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])];
|
|
301
|
+
return labels.map((label) => {
|
|
302
|
+
const from = a[label] ?? null;
|
|
303
|
+
const to = b[label] ?? null;
|
|
304
|
+
return { label, from, to, delta: from !== null && to !== null ? to - from : null };
|
|
305
|
+
});
|
|
306
|
+
}
|
|
307
|
+
function flagSession(s, interp) {
|
|
308
|
+
const T = SESSION_FLAG_THRESHOLDS;
|
|
309
|
+
const { doc, accuracy, eloNet } = s;
|
|
310
|
+
const flags = [];
|
|
311
|
+
const cards = doc.tally?.cardsPresented ?? 0;
|
|
312
|
+
const runs = doc.runs?.length ?? 0;
|
|
313
|
+
if (cards >= T.churnMinCards && runs / cards > T.churnRunsPerCard) flags.push("churned");
|
|
314
|
+
if (doc.status === "closed" && (doc.tally?.secondsRemaining ?? 0) > T.outOfContentSeconds) {
|
|
315
|
+
flags.push("out-of-content");
|
|
316
|
+
}
|
|
317
|
+
if (doc.status === "open") flags.push("walked");
|
|
318
|
+
else if (doc.status === "abandoned" && cards >= T.walkMinCards) flags.push("walked");
|
|
319
|
+
const progress = s.state.filter((r) => interp?.progressMetrics?.includes(r.label));
|
|
320
|
+
const measurable = eloNet !== null || progress.some((r) => r.delta !== null);
|
|
321
|
+
if (cards > 0 && measurable && progress.every((r) => (r.delta ?? 0) === 0) && Math.abs(eloNet ?? 0) < T.stallEloEpsilon) {
|
|
322
|
+
flags.push("stalled");
|
|
323
|
+
}
|
|
324
|
+
if (accuracy !== null && accuracy < T.grindAccuracy && cards > 0 || (doc.tally?.failedQRemaining ?? 0) > 0) {
|
|
325
|
+
flags.push("grinding");
|
|
326
|
+
}
|
|
327
|
+
return flags;
|
|
328
|
+
}
|
|
329
|
+
function summarizeSession(doc, interp) {
|
|
330
|
+
const start = Date.parse(doc.startTime);
|
|
331
|
+
const end = doc.endTime ? Date.parse(doc.endTime) : NaN;
|
|
332
|
+
const durationSeconds = Number.isNaN(start) || Number.isNaN(end) ? null : Math.round((end - start) / 1e3);
|
|
333
|
+
const responses = doc.tally?.responses ?? 0;
|
|
334
|
+
const accuracy = responses > 0 ? (doc.tally?.correct ?? 0) / responses : null;
|
|
335
|
+
const events = doc.eloEvents ?? [];
|
|
336
|
+
const eloNet = events.length ? events.reduce((n, e) => n + (e.global.after - e.global.before), 0) : null;
|
|
337
|
+
const base = { doc, durationSeconds, accuracy, eloNet, state: stateRows(doc, interp) };
|
|
338
|
+
return { ...base, flags: flagSession(base, interp) };
|
|
339
|
+
}
|
|
340
|
+
function summarizeSessions(ds, interp) {
|
|
341
|
+
return ds.sessions.map((d) => summarizeSession(d, interp)).reverse();
|
|
342
|
+
}
|
|
343
|
+
function toResponseEloDelta(ev, interp) {
|
|
344
|
+
const order = bySkillThenName(interp);
|
|
345
|
+
const tags = Object.entries(ev.tags ?? {}).map(([tag, t]) => ({
|
|
346
|
+
tag,
|
|
347
|
+
before: t.before,
|
|
348
|
+
after: t.after,
|
|
349
|
+
delta: t.after - t.before,
|
|
350
|
+
score: t.score
|
|
351
|
+
})).sort((a, b) => order(a.tag, b.tag));
|
|
352
|
+
return {
|
|
353
|
+
userScore: ev.userScore,
|
|
354
|
+
global: {
|
|
355
|
+
before: ev.global.before,
|
|
356
|
+
after: ev.global.after,
|
|
357
|
+
delta: ev.global.after - ev.global.before
|
|
358
|
+
},
|
|
359
|
+
...ev.card ? {
|
|
360
|
+
card: {
|
|
361
|
+
before: ev.card.before,
|
|
362
|
+
after: ev.card.after,
|
|
363
|
+
delta: ev.card.after - ev.card.before
|
|
364
|
+
}
|
|
365
|
+
} : {},
|
|
366
|
+
tags
|
|
367
|
+
};
|
|
368
|
+
}
|
|
369
|
+
function attachEloEvents(responses, events, interp) {
|
|
370
|
+
const used = /* @__PURE__ */ new Set();
|
|
371
|
+
for (const ev of events) {
|
|
372
|
+
const evT = Date.parse(ev.at);
|
|
373
|
+
let best = -1;
|
|
374
|
+
let bestGap = Infinity;
|
|
375
|
+
responses.forEach((r, i) => {
|
|
376
|
+
if (used.has(i) || r.cardId !== ev.cardId) return;
|
|
377
|
+
const gap = Math.abs(Date.parse(r.at) - evT);
|
|
378
|
+
if (gap < bestGap) {
|
|
379
|
+
bestGap = gap;
|
|
380
|
+
best = i;
|
|
381
|
+
}
|
|
382
|
+
});
|
|
383
|
+
if (best >= 0) {
|
|
384
|
+
used.add(best);
|
|
385
|
+
responses[best].elo = toResponseEloDelta(ev, interp);
|
|
386
|
+
}
|
|
387
|
+
}
|
|
388
|
+
}
|
|
389
|
+
function byTime(a, b) {
|
|
390
|
+
const ta = Date.parse(a.at);
|
|
391
|
+
const tb = Date.parse(b.at);
|
|
392
|
+
if (Number.isNaN(ta) || Number.isNaN(tb)) return a.at.localeCompare(b.at);
|
|
393
|
+
return ta - tb;
|
|
394
|
+
}
|
|
395
|
+
function sessionDetail(ds, sessionId, interp) {
|
|
396
|
+
const doc = ds.sessions.find((s) => s.sessionId === sessionId);
|
|
397
|
+
if (!doc) return null;
|
|
398
|
+
const responses = [];
|
|
399
|
+
for (const h of ds.cardHistories) {
|
|
400
|
+
const card = ds.cards?.get(h.cardID);
|
|
401
|
+
for (const r of h.records) {
|
|
402
|
+
if (r.sessionId !== sessionId) continue;
|
|
403
|
+
responses.push({
|
|
404
|
+
kind: "response",
|
|
405
|
+
at: r.timeStamp,
|
|
406
|
+
cardId: h.cardID,
|
|
407
|
+
...card ? { card, questionType: card.questionType } : {},
|
|
408
|
+
tags: card ? [...card.tags].sort(bySkillThenName(interp)) : [],
|
|
409
|
+
isCorrect: typeof r.isCorrect === "boolean" ? r.isCorrect : null,
|
|
410
|
+
timeSpentMs: r.timeSpent ?? 0,
|
|
411
|
+
priorAttempts: typeof r.priorAttemps === "number" ? r.priorAttemps : null,
|
|
412
|
+
userAnswer: r.userAnswer
|
|
413
|
+
});
|
|
414
|
+
}
|
|
415
|
+
}
|
|
416
|
+
if (doc.eloEvents?.length) attachEloEvents(responses, doc.eloEvents, interp);
|
|
417
|
+
const runs = (doc.runs ?? []).map((run) => ({ kind: "run", at: run.at, run }));
|
|
418
|
+
const timeline = [...runs, ...responses].sort(byTime);
|
|
419
|
+
return {
|
|
420
|
+
summary: summarizeSession(doc, interp),
|
|
421
|
+
timeline,
|
|
422
|
+
responsesMissing: (doc.tally?.responses ?? 0) > responses.length
|
|
423
|
+
};
|
|
424
|
+
}
|
|
425
|
+
function servedTags(timeline, interp) {
|
|
426
|
+
const byTag = /* @__PURE__ */ new Map();
|
|
427
|
+
for (const e of timeline) {
|
|
428
|
+
if (e.kind !== "response") continue;
|
|
429
|
+
for (const tag of e.tags) {
|
|
430
|
+
let s = byTag.get(tag);
|
|
431
|
+
if (!s) {
|
|
432
|
+
s = { responses: 0, correct: 0, incorrect: 0, totalTimeMs: 0, cards: /* @__PURE__ */ new Set() };
|
|
433
|
+
byTag.set(tag, s);
|
|
434
|
+
}
|
|
435
|
+
s.responses += 1;
|
|
436
|
+
s.totalTimeMs += e.timeSpentMs;
|
|
437
|
+
s.cards.add(e.cardId);
|
|
438
|
+
if (e.isCorrect === true) s.correct += 1;
|
|
439
|
+
else if (e.isCorrect === false) s.incorrect += 1;
|
|
440
|
+
}
|
|
441
|
+
}
|
|
442
|
+
return [...byTag.entries()].map(([tag, s]) => {
|
|
443
|
+
const graded = s.correct + s.incorrect;
|
|
444
|
+
return {
|
|
445
|
+
tag,
|
|
446
|
+
responses: s.responses,
|
|
447
|
+
correct: s.correct,
|
|
448
|
+
incorrect: s.incorrect,
|
|
449
|
+
accuracy: graded > 0 ? s.correct / graded : null,
|
|
450
|
+
totalTimeMs: s.totalTimeMs,
|
|
451
|
+
cards: s.cards.size
|
|
452
|
+
};
|
|
453
|
+
}).sort((a, b) => {
|
|
454
|
+
const d = Number(isSkillTag(interp, b.tag)) - Number(isSkillTag(interp, a.tag));
|
|
455
|
+
if (d !== 0) return d;
|
|
456
|
+
if (b.responses !== a.responses) return b.responses - a.responses;
|
|
457
|
+
return a.tag.localeCompare(b.tag);
|
|
458
|
+
});
|
|
459
|
+
}
|
|
460
|
+
function eloLedger(timeline) {
|
|
461
|
+
const ledger = { count: 0, net: 0, gained: 0, lost: 0, wins: 0, losses: 0 };
|
|
462
|
+
for (const e of timeline) {
|
|
463
|
+
if (e.kind !== "response" || !e.elo) continue;
|
|
464
|
+
const g = e.elo.global.delta;
|
|
465
|
+
ledger.count += 1;
|
|
466
|
+
ledger.net += g;
|
|
467
|
+
if (g > 0) {
|
|
468
|
+
ledger.gained += g;
|
|
469
|
+
ledger.wins += 1;
|
|
470
|
+
} else if (g < 0) {
|
|
471
|
+
ledger.lost += g;
|
|
472
|
+
ledger.losses += 1;
|
|
473
|
+
}
|
|
474
|
+
}
|
|
475
|
+
return ledger.count ? ledger : null;
|
|
476
|
+
}
|
|
477
|
+
var FROZEN_FAIL_THRESHOLD = 3;
|
|
478
|
+
function cardDossiers(ds) {
|
|
479
|
+
const asOf = Date.parse(ds.asOf);
|
|
480
|
+
const pending = /* @__PURE__ */ new Map();
|
|
481
|
+
for (const s of ds.scheduled) {
|
|
482
|
+
const t = String(s.reviewTime);
|
|
483
|
+
const prev = pending.get(s.cardId);
|
|
484
|
+
if (!prev || t < prev) pending.set(s.cardId, t);
|
|
485
|
+
}
|
|
486
|
+
return ds.cardHistories.map((h) => {
|
|
487
|
+
const card = ds.cards?.get(h.cardID);
|
|
488
|
+
const fails = h.records.filter((r) => r.isCorrect === false).length;
|
|
489
|
+
const totalTimeMs = h.records.reduce((n, r) => n + (r.timeSpent ?? 0), 0);
|
|
490
|
+
const reviewTime = pending.get(h.cardID);
|
|
491
|
+
const pendingReview = reviewTime ? { reviewTime, overdue: Date.parse(reviewTime) <= asOf } : null;
|
|
492
|
+
const cardElo = card?.elo?.global?.score ?? null;
|
|
493
|
+
const cardEloCount = card?.elo?.global?.count ?? null;
|
|
494
|
+
return {
|
|
495
|
+
cardId: h.cardID,
|
|
496
|
+
...card ? { card } : {},
|
|
497
|
+
records: h.records,
|
|
498
|
+
lapses: h.lapses ?? 0,
|
|
499
|
+
streak: h.streak ?? 0,
|
|
500
|
+
bestIntervalSeconds: h.bestInterval ?? 0,
|
|
501
|
+
attempts: h.records.length,
|
|
502
|
+
fails,
|
|
503
|
+
firstSeen: h.records[0]?.timeStamp ?? null,
|
|
504
|
+
lastSeen: h.records[h.records.length - 1]?.timeStamp ?? null,
|
|
505
|
+
totalTimeMs,
|
|
506
|
+
pendingReview,
|
|
507
|
+
cardElo,
|
|
508
|
+
cardEloCount,
|
|
509
|
+
stuck: fails > 0 && !!pendingReview?.overdue,
|
|
510
|
+
frozenElo: fails >= FROZEN_FAIL_THRESHOLD && cardEloCount !== null && cardEloCount < fails,
|
|
511
|
+
painScore: totalTimeMs * (fails + 1)
|
|
512
|
+
};
|
|
513
|
+
}).sort((a, b) => b.painScore - a.painScore);
|
|
514
|
+
}
|
|
515
|
+
function recordPerformance(r) {
|
|
516
|
+
const p = r.performance;
|
|
517
|
+
if (typeof p === "number") return p;
|
|
518
|
+
if (p && typeof p === "object" && typeof p._global === "number") {
|
|
519
|
+
return p._global;
|
|
520
|
+
}
|
|
521
|
+
return null;
|
|
522
|
+
}
|
|
523
|
+
|
|
524
|
+
// src/diagnostics/text.ts
|
|
525
|
+
function fmtDelta(d) {
|
|
526
|
+
if (d === null) return "\u2014";
|
|
527
|
+
if (d === 0) return "0";
|
|
528
|
+
const v = Number.isInteger(d) ? d : Number(d.toFixed(1));
|
|
529
|
+
return v > 0 ? `+${v}` : String(v);
|
|
530
|
+
}
|
|
531
|
+
function fmtDuration(seconds) {
|
|
532
|
+
const s = Math.max(0, Math.round(seconds));
|
|
533
|
+
if (s < 60) return `${s}s`;
|
|
534
|
+
const m = Math.floor(s / 60);
|
|
535
|
+
if (m < 60) return s % 60 ? `${m}m${s % 60}s` : `${m}m`;
|
|
536
|
+
return `${(m / 60).toFixed(1)}h`;
|
|
537
|
+
}
|
|
538
|
+
function fmtAnswer(a, max = 40) {
|
|
539
|
+
if (a == null) return "";
|
|
540
|
+
if (typeof a === "string" || typeof a === "number") return String(a);
|
|
541
|
+
try {
|
|
542
|
+
const s = JSON.stringify(a);
|
|
543
|
+
return s.length > max ? `${s.slice(0, max)}\u2026` : s;
|
|
544
|
+
} catch {
|
|
545
|
+
return String(a);
|
|
546
|
+
}
|
|
547
|
+
}
|
|
548
|
+
function fmtScore(n) {
|
|
549
|
+
return Math.abs(n) >= 0.01 || n === 0 ? n.toFixed(2) : n.toExponential(1);
|
|
550
|
+
}
|
|
551
|
+
function trailText(label, t) {
|
|
552
|
+
const lines = [
|
|
553
|
+
` ${label}: ${t.cardId} (${t.origin}, ${t.generator ?? "?"}) final ${fmtScore(t.score)}`
|
|
554
|
+
];
|
|
555
|
+
for (const p of t.trail) {
|
|
556
|
+
lines.push(` ${p.action} ${p.strategyName} \u2192 ${fmtScore(p.score)}: ${p.reason}`);
|
|
557
|
+
}
|
|
558
|
+
return lines;
|
|
559
|
+
}
|
|
560
|
+
function runText(run) {
|
|
561
|
+
const L = [];
|
|
562
|
+
L.push(
|
|
563
|
+
`RUN ${run.label}${run.mode ? ` [${run.mode}]` : ""} @ ${run.at} \u2014 generated ${run.generatedCount} \u2192 selected ${run.finalCount} (${run.newSelected} new, ${run.reviewsSelected} review)` + (run.generatedCount > 0 && run.finalCount === 0 ? " \u26A0 nothing survived" : "")
|
|
564
|
+
);
|
|
565
|
+
if (typeof run.userElo === "number") L.push(` userElo: ${Math.round(run.userElo)}`);
|
|
566
|
+
if (run.generators?.length) {
|
|
567
|
+
L.push(" generators:");
|
|
568
|
+
for (const g of run.generators) {
|
|
569
|
+
L.push(
|
|
570
|
+
` - ${g.name}: ${g.cardCount} cards (${g.newCount} new, ${g.reviewCount} review), topScore ${g.topScore.toFixed(2)}`
|
|
571
|
+
);
|
|
572
|
+
}
|
|
573
|
+
}
|
|
574
|
+
if (run.filters?.length) {
|
|
575
|
+
L.push(" filters:");
|
|
576
|
+
for (const f of run.filters) {
|
|
577
|
+
L.push(
|
|
578
|
+
` - ${f.name}: +${f.boosted} boosted, -${f.penalized} penalized, ${f.passed} passed, ${f.removed} removed`
|
|
579
|
+
);
|
|
580
|
+
}
|
|
581
|
+
}
|
|
582
|
+
if (run.hints) L.push(` hints: ${JSON.stringify(run.hints)}`);
|
|
583
|
+
if (run.cards?.length) {
|
|
584
|
+
L.push(" selection (\u2713 selected, \xB7 runner-up):");
|
|
585
|
+
for (const c of run.cards) {
|
|
586
|
+
L.push(
|
|
587
|
+
` ${c.selected ? "\u2713" : "\xB7"} ${c.cardId} (${c.origin}, ${c.generator ?? "?"}) ${fmtScore(c.score)}`
|
|
588
|
+
);
|
|
589
|
+
}
|
|
590
|
+
}
|
|
591
|
+
if (run.unselectedNew?.nextInLine)
|
|
592
|
+
L.push(...trailText("next new in line", run.unselectedNew.nextInLine));
|
|
593
|
+
if (run.unselectedNew?.topGenerated) {
|
|
594
|
+
L.push(...trailText("top-generated new (sunk)", run.unselectedNew.topGenerated));
|
|
595
|
+
}
|
|
596
|
+
if (run.discardedTail) {
|
|
597
|
+
const t = run.discardedTail;
|
|
598
|
+
L.push(
|
|
599
|
+
` discardedTail: ${t.count} cards` + (t.scoreRange ? ` \xB7 score [${t.scoreRange[0].toFixed(2)}, ${t.scoreRange[1].toFixed(2)}]` : "") + (t.eloRange ? ` \xB7 elo [${Math.round(t.eloRange[0])}, ${Math.round(t.eloRange[1])}]` : "")
|
|
600
|
+
);
|
|
601
|
+
if (t.note) L.push(` ${t.note}`);
|
|
602
|
+
}
|
|
603
|
+
return L.join("\n");
|
|
604
|
+
}
|
|
605
|
+
function scoredTagDeltas(elo) {
|
|
606
|
+
return elo.tags.filter((t) => t.score !== null && t.delta !== 0).slice(0, 4);
|
|
607
|
+
}
|
|
608
|
+
function eloSuffix(elo, interp) {
|
|
609
|
+
if (!elo) return "";
|
|
610
|
+
const g = `ELO g:${elo.global.before}\u2192${elo.global.after} (${fmtDelta(elo.global.delta)})`;
|
|
611
|
+
const tags = scoredTagDeltas(elo).map((t) => `${shortTag(interp, t.tag)}:${fmtDelta(t.delta)}`);
|
|
612
|
+
return ` ${g}${tags.length ? ` | ${tags.join(" ")}` : ""}`;
|
|
613
|
+
}
|
|
614
|
+
function clock(iso) {
|
|
615
|
+
const d = new Date(iso);
|
|
616
|
+
return Number.isNaN(d.getTime()) ? iso : d.toISOString().slice(11, 19);
|
|
617
|
+
}
|
|
618
|
+
function sessionText(username, detail, extras = {}, interp) {
|
|
619
|
+
const s = detail.summary;
|
|
620
|
+
const doc = s.doc;
|
|
621
|
+
const responses = detail.timeline.filter((e) => e.kind === "response").length;
|
|
622
|
+
const L = [];
|
|
623
|
+
L.push(`# Study session ${doc.sessionId} \u2014 user ${username}`);
|
|
624
|
+
L.push("");
|
|
625
|
+
L.push("## Legend");
|
|
626
|
+
L.push("- The TIMELINE is one time-ordered stream: RUN lines are pipeline (re)plans;");
|
|
627
|
+
L.push(" the lines between them are card responses in the order presented.");
|
|
628
|
+
L.push('- RUN "generated N \u2192 selected M (a new, b review)": the pipeline produced N');
|
|
629
|
+
L.push(' candidates and chose M. "nothing survived" = generated > 0 but 0 selected.');
|
|
630
|
+
L.push(" Bootstrap runs fire before card #1; replans are interleaved by time.");
|
|
631
|
+
L.push("- generators: each source's contribution. filters: how each reshaped scores.");
|
|
632
|
+
L.push(" hints: the ReplanHints the navigator was told (_label = replan reason).");
|
|
633
|
+
L.push(' selection: the chosen cards and top runners-up. "next new in line" / "top-generated');
|
|
634
|
+
L.push(' new (sunk)": the unselected new cards worth explaining, with each score change.');
|
|
635
|
+
L.push(' Prescribed and hint-required cards count as origin "unknown" (known miscount).');
|
|
636
|
+
L.push(`- RESP "\u2713/\u2717 type <cardId> [tags] Ts (attempt k) 'answer'": one presentation and`);
|
|
637
|
+
L.push(' its outcome. A trailing "ELO g:before\u2192after (\u0394) | tag:\u0394 \u2026" is the exchange it');
|
|
638
|
+
L.push(" produced. Only first attempts move ELO.");
|
|
639
|
+
L.push("");
|
|
640
|
+
L.push("## Headline");
|
|
641
|
+
L.push(`- status: ${doc.status}`);
|
|
642
|
+
L.push(`- start: ${doc.startTime}${doc.endTime ? ` \xB7 end: ${doc.endTime}` : ""}`);
|
|
643
|
+
L.push(
|
|
644
|
+
`- clock: ${s.durationSeconds ?? "\u2014"}s of ${doc.plannedSeconds}s planned` + (doc.tally ? ` \xB7 ${doc.tally.secondsRemaining}s remaining` : "")
|
|
645
|
+
);
|
|
646
|
+
if (doc.tally) {
|
|
647
|
+
L.push(
|
|
648
|
+
`- tally: ${doc.tally.cardsPresented} cards, ${doc.tally.responses} responses (${doc.tally.correct} correct / ${doc.tally.incorrect} incorrect) \xB7 failedQ remaining ${doc.tally.failedQRemaining}`
|
|
649
|
+
);
|
|
650
|
+
}
|
|
651
|
+
L.push(`- flags: ${s.flags.length ? s.flags.join(", ") : "none"}`);
|
|
652
|
+
L.push(
|
|
653
|
+
`- config: batchLimit ${doc.config?.defaultBatchLimit ?? "?"}, ${doc.config?.sourceCount ?? "?"} source(s), opening queues supply ${doc.initialQueues?.supplyQ ?? "?"} / failed ${doc.initialQueues?.failedQ ?? "?"}`
|
|
654
|
+
);
|
|
655
|
+
if (detail.responsesMissing) {
|
|
656
|
+
L.push(
|
|
657
|
+
`- \u26A0 responsesMissing: tally claims ${doc.tally?.responses} responses but only ${responses} stamped records were found.`
|
|
658
|
+
);
|
|
659
|
+
}
|
|
660
|
+
L.push("");
|
|
661
|
+
if (s.state.length) {
|
|
662
|
+
L.push("## Learner state (start \u2192 end, \u0394)");
|
|
663
|
+
for (const r of s.state)
|
|
664
|
+
L.push(`- ${r.label}: ${r.from ?? "\u2014"} \u2192 ${r.to ?? "\u2014"} (${fmtDelta(r.delta)})`);
|
|
665
|
+
L.push("");
|
|
666
|
+
}
|
|
667
|
+
L.push("## Session hints");
|
|
668
|
+
L.push(`- at open: ${doc.config?.initHints ? JSON.stringify(doc.config.initHints) : "none"}`);
|
|
669
|
+
L.push(`- at close: ${doc.finalHints ? JSON.stringify(doc.finalHints) : "none"}`);
|
|
670
|
+
L.push("");
|
|
671
|
+
if (extras.servedTags?.length) {
|
|
672
|
+
L.push("## Served tags");
|
|
673
|
+
for (const t of extras.servedTags) {
|
|
674
|
+
L.push(
|
|
675
|
+
`- ${t.tag}: ${t.responses} resp / ${t.cards} card(s), acc ${t.accuracy === null ? "n/a" : `${Math.round(t.accuracy * 100)}%`} (${t.correct}\u2713/${t.incorrect}\u2717), ${(t.totalTimeMs / 1e3).toFixed(1)}s`
|
|
676
|
+
);
|
|
677
|
+
}
|
|
678
|
+
L.push("");
|
|
679
|
+
}
|
|
680
|
+
const led = extras.eloLedger;
|
|
681
|
+
if (led) {
|
|
682
|
+
L.push("## ELO ledger (learner global)");
|
|
683
|
+
L.push(
|
|
684
|
+
`- net ${fmtDelta(led.net)} across ${led.count} exchange(s) \xB7 gained ${fmtDelta(led.gained)} over ${led.wins} win(s) \xB7 lost ${fmtDelta(led.lost)} over ${led.losses} loss(es)`
|
|
685
|
+
);
|
|
686
|
+
L.push("");
|
|
687
|
+
}
|
|
688
|
+
L.push(`## Timeline (${detail.timeline.length} entries)`);
|
|
689
|
+
for (const e of detail.timeline) {
|
|
690
|
+
if (e.kind === "run") {
|
|
691
|
+
L.push(runText(e.run));
|
|
692
|
+
continue;
|
|
693
|
+
}
|
|
694
|
+
const mark = e.isCorrect === true ? "\u2713" : e.isCorrect === false ? "\u2717" : "\xB7";
|
|
695
|
+
const tags = e.tags.length ? ` [${e.tags.join(", ")}]` : "";
|
|
696
|
+
const attempt = e.priorAttempts ? ` (attempt ${e.priorAttempts + 1})` : "";
|
|
697
|
+
const ans = e.userAnswer != null ? ` '${fmtAnswer(e.userAnswer)}'` : "";
|
|
698
|
+
L.push(
|
|
699
|
+
`RESP ${clock(e.at)} ${mark} ${e.questionType ?? "card"} ${e.cardId}${tags} \u2014 ${(e.timeSpentMs / 1e3).toFixed(1)}s${attempt}${ans}${eloSuffix(e.elo, interp)}`
|
|
700
|
+
);
|
|
701
|
+
}
|
|
702
|
+
return L.join("\n");
|
|
703
|
+
}
|
|
704
|
+
export {
|
|
705
|
+
SESSION_FLAGS,
|
|
706
|
+
SESSION_FLAG_THRESHOLDS,
|
|
707
|
+
cardDossiers,
|
|
708
|
+
dumpFileName,
|
|
709
|
+
eloLedger,
|
|
710
|
+
fetchLearnerDump,
|
|
711
|
+
fmtAnswer,
|
|
712
|
+
fmtDelta,
|
|
713
|
+
fmtDuration,
|
|
714
|
+
fromDump,
|
|
715
|
+
isSkillTag,
|
|
716
|
+
parseLearnerDump,
|
|
717
|
+
recordPerformance,
|
|
718
|
+
runText,
|
|
719
|
+
scoredTagDeltas,
|
|
720
|
+
servedTags,
|
|
721
|
+
sessionDetail,
|
|
722
|
+
sessionText,
|
|
723
|
+
shortTag,
|
|
724
|
+
summarizeSession,
|
|
725
|
+
summarizeSessions,
|
|
726
|
+
toIsoTimestamp,
|
|
727
|
+
userDbName
|
|
728
|
+
};
|
|
729
|
+
//# sourceMappingURL=index.mjs.map
|