@ivanbard/dd2l 0.0.0-stage → 0.1.1

package/src/task-workspace.mjs

@@ -0,0 +1,138 @@
+import { createHash } from 'node:crypto';
+import { matches } from '../ui/answer-view.js';
+import { researchActions } from './research.mjs';
+
+const text = maxLength => ({ type: 'string', maxLength });
+const object = properties => ({ type: 'object', properties, required: Object.keys(properties), additionalProperties: false });
+const list = (items, maxItems, minItems = 0) => ({ type: 'array', items, minItems, maxItems });
+export const workspacePlanSchema = object({
+  title: text(160), goal: text(1000), question: text(500),
+  sections: list(object({ title: text(160), purpose: text(500), sourceIds: list(text(80), 24, 1) }), 8),
+});
+
+const fail = message => Object.assign(new Error(message), { public: true });
+const excerpt = (value, length) => value.length > length ? `${value.slice(0, length)}\n[Excerpt truncated.]` : value;
+
+export function taskCatalogue(inventory, course = '') {
+  const allowed = new Set(inventory.courses.filter(item => !course || item.id === course).map(item => item.id));
+  const parents = new Set((inventory.assignments || []).map(assignment => `${assignment.course}:${assignment.id}`));
+  const sources = inventory.sources.filter(source => {
+    const assignment = source.id.match(/\/dropbox\/folders\/(\d+)(?:\/|#|$)/)?.[1] ||
+      (source.category === 'rubrics' ? source.id.match(/[?&]objectId=(\d+)(?:&|#|$)/)?.[1] : null);
+    return allowed.has(source.course) && (!assignment || parents.has(`${source.course}:${assignment}`));
+  }).map(source => ({ ...source,
+    ref: JSON.stringify([source.course, source.category, source.id, source.title]),
+  }));
+  for (const assignment of inventory.assignments || []) {
+    if (!allowed.has(assignment.course)) continue;
+    const parent = `${assignment.course}:${assignment.id}`;
+    sources.push({ ...assignment, category: 'assignment', ref: `${parent}:overview`,
+      text: `Due: ${assignment.dueDate || 'Not retrieved'}\nOpens: ${assignment.startDate || 'Not retrieved'}\nCloses: ${assignment.endDate || 'Not retrieved'}\n${assignment.submissionStatus}`,
+      records: undefined, parent });
+    for (const record of assignment.records) sources.push({ ...record, title: `${assignment.title} · ${record.title}`,
+      text: record.text || `${record.title}: ${record.status}. No readable text retrieved.`, ref: record.id, parent });
+  }
+  return sources.map(({ ref, records, ...source }) => ({ ...source,
+    id: createHash('sha256').update(ref).digest('base64url').slice(0, 24),
+  }));
+}
+
+// Bounded catalogue selection is distinct from evidence selection: the model sees varied records,
+// including records with no literal query overlap, and can follow assignment relationships.
+export function planningCatalogue(sources, query, context = null, preferred = []) {
+  const terms = [...new Set(query.toLowerCase().match(/[\p{L}\p{N}]{3,}/gu) || [])];
+  const previous = new Set(context?.sourceIds || []);
+  const ranked = sources.map((source, index) => ({ source, index,
+    score: (previous.has(source.id) ? 10 : 0) + terms.reduce((score, term) => score +
+      (source.title.toLowerCase().includes(term) ? 3 : source.text.toLowerCase().includes(term) ? 1 : 0), 0),
+  })).sort((a, b) => {
+    const left = preferred.indexOf(a.source.id), right = preferred.indexOf(b.source.id);
+    return (left < 0 ? Infinity : left) - (right < 0 ? Infinity : right) || b.score - a.score || a.index - b.index;
+  });
+  const selected = new Map(ranked.slice(0, 200).map(({ source }) => [source.id, source]));
+  // Reserve space for every course/category rather than letting a large course crowd out others.
+  const buckets = new Map();
+  for (const source of sources) {
+    const key = `${source.course}:${source.category}`;
+    if (!buckets.has(key)) buckets.set(key, []);
+    buckets.get(key).push(source);
+  }
+  for (let round = 0; selected.size < 400; round++) {
+    let added = false;
+    for (const bucket of buckets.values()) {
+      if (selected.size >= 400) break;
+      const source = bucket[round];
+      if (source && !selected.has(source.id)) { selected.set(source.id, source); added = true; }
+    }
+    if (!added && [...buckets.values()].every(bucket => round >= bucket.length)) break;
+  }
+  return [...selected.values()].map(source => ({ id: source.id, course: source.courseName, category: source.category,
+    title: excerpt(source.title, 200), preview: excerpt(source.text, 400), parent: source.parent || null,
+    dueDate: source.dueDate || null, stale: !!source.stale, status: source.status || 'available',
+  }));
+}
+
+export function buildTaskWorkspace(plan, sources, catalogueCount, total) {
+  const byId = new Map(sources.map(source => [source.id, source]));
+  if (!matches(plan, workspacePlanSchema) || !plan.title.trim() || !plan.goal.trim() || plan.sections.some(section => !section.sourceIds.length ||
+    section.sourceIds.some(id => !byId.has(id)))) throw fail('The workspace plan could not be verified. Please retry.');
+  const ids = [...new Set(plan.sections.flatMap(section => section.sourceIds))];
+  if (ids.length > 24 || (!ids.length && !plan.question.trim())) throw fail('The workspace plan needs sources or a clarifying question. Please retry.');
+  const evidence = ids.map(id => {
+    const { text, ...source } = byId.get(id);
+    return { ...source, excerpt: excerpt(text, 8000) };
+  });
+  return { workspace: { kind: 'task', title: plan.title, goal: plan.goal, question: plan.question,
+    sections: plan.sections.map(section => ({ ...section, sources: section.sourceIds.map(id => {
+      const source = byId.get(id);
+      return { id, title: source.title, category: source.category, courseName: source.courseName,
+        text: excerpt(source.text, 30_000), url: source.url, dueDate: source.dueDate || null,
+        stale: !!source.stale, status: source.status || 'available', lastSuccess: source.lastSuccess || null };
+    }) })),
+    context: { goal: plan.goal, sourceIds: ids }, catalogueCount, total }, sources: evidence };
+}
+
+export function validTaskContext(context) {
+  if (context === null) return true;
+  if (!context || typeof context !== 'object' || Array.isArray(context)) return false;
+  const { summary, ...references } = context;
+  return matches(references, object({ goal: text(1000), sourceIds: list(text(80), 24) })) &&
+    (summary === undefined || (typeof summary === 'string' && summary.length <= 12_000));
+}
+
+export async function composeTaskWorkspace(llm, inventory, query, model, course, context, signal, refresh = () => inventory, research = null) {
+  let accountScope = inventory.scope;
+  const checkedInventory = value => {
+    if (accountScope && value.scope !== accountScope) throw fail('School account changed or its cache was cleared. Start a new request.');
+    accountScope ||= value.scope;
+    return value;
+  };
+  for (let round = 0; round <= 4; round++) {
+    signal?.throwIfAborted();
+    const current = checkedInventory(round ? refresh() : inventory);
+    const all = taskCatalogue(current, course);
+    const preferred = research ? all.filter(source => research.keys.has(source.resourceKey))
+      .sort((a, b) => Number(!a.category.includes('file')) - Number(!b.category.includes('file')) || (Date.parse(b.lastSuccess) || 0) - (Date.parse(a.lastSuccess) || 0)).map(source => source.id) : [];
+    const catalogue = planningCatalogue(all, query, context, preferred);
+    const plan = await llm.planWorkspace(query, model, { catalogue, total: all.length,
+      courses: current.courses.filter(item => !course || item.id === course), now: new Date().toISOString(),
+      ...(research ? { browsing: { available: round < 4 && research.available, remaining: round < 4 ? research.remaining : 0, history: research.history } } : {}),
+    }, context, signal);
+    if (plan.requests?.length) {
+      if (!matches(plan.requests, researchActions)) throw fail('The model returned invalid Brightspace read requests.');
+      if (!research || round === 4 || !research.available) throw fail('The model exceeded the live reading budget. Please narrow your request.');
+      if (plan.sections?.length) throw fail('The model must finish reading before selecting workspace sources.');
+      for (const action of plan.requests) {
+        if (!research.available) break;
+        await research.execute(action);
+      }
+      continue;
+    }
+    const { requests, ...finalPlan } = plan;
+    const visible = new Set(catalogue.map(source => source.id));
+    const task = buildTaskWorkspace(finalPlan, taskCatalogue(checkedInventory(refresh()), course).filter(source => visible.has(source.id)), catalogue.length, all.length);
+    if (research?.history.length) task.workspace.research = research.history.map(({ action, result }) => ({ action: action.action,
+      section: action.section || 'resource', outcome: result.outcome, message: result.message || '', outcomes: result.outcomes || [] }));
+    return task;
+  }
+}

package/src/ui-data.mjs

@@ -0,0 +1,123 @@
+import { DatabaseSync } from 'node:sqlite';
+import { htmlContent } from './documents.mjs';
+import { SCHOOL, schoolOrigin } from './client.mjs';
+import { createHash } from 'node:crypto';
+import { projectAssignments } from './assignment-workspace.mjs';
+
+const categories = new Set(['content', 'overview', 'syllabus_source', 'assignments', 'quizzes', 'announcements',
+  'calendar', 'calendar_occurrences', 'content_file', 'assignment_file', 'linked_content', 'video_transcript',
+  'quiz_details', 'own_quiz_attempts', 'grades', 'own_feedback', 'feedback_file', 'rubrics',
+  'discussion_forums', 'discussion_topics', 'discussion_posts', 'discussion_file']);
+const textFields = new Set(['Title', 'Name', 'Subject', 'Text', 'Html', 'text', 'Description', 'Instructions',
+  'Body', 'Content', 'StartDate', 'EndDate', 'DueDate', 'StartDateTime', 'EndDateTime',
+  'DisplayedGrade', 'PointsNumerator', 'PointsDenominator', 'WeightedNumerator', 'WeightedDenominator',
+  'Feedback', 'FeedbackText', 'Score', 'Points', 'MaxPoints', 'CompletionDate', 'TimeLimit']);
+
+// Open for each request so logout, revoked access and new syncs are reflected immediately.
+export function readInventory(path) {
+  let db;
+  try {
+    db = new DatabaseSync(path, { readOnly: true });
+    db.exec('PRAGMA busy_timeout=3000; BEGIN');
+    const meta = key => {
+      const row = db.prepare('SELECT value FROM meta WHERE key=?').get(key);
+      return row ? JSON.parse(row.value) : null;
+    };
+    const state = meta('state');
+    const rows = db.prepare(`SELECT key,course,category,data,last_success,checked_at,outcome
+      FROM resources`).all()
+      .map(row => ({ ...row, data: JSON.parse(row.data) }));
+    const account = meta('account');
+    return { ...projectInventory(rows, state, meta('school_origin') ?? SCHOOL), scope: account ? createHash('sha256').update(account).digest('hex') : null };
+  } catch (error) {
+    if (error.code === 'ERR_SQLITE_ERROR' && /unable to open database/.test(error.message)) {
+      return { courses: [], sources: [], state: null };
+    }
+    throw error;
+  } finally { db?.close(); }
+}
+
+export function projectInventory(rows, state, origin = SCHOOL) {
+  origin = schoolOrigin(origin);
+  const enrollment = rows.find(row => row.category === 'enrollments' && !['denied', 'not_configured'].includes(row.outcome));
+  const courses = (enrollment?.data ?? []).filter(item => item.Access?.CanAccess === true && item.OrgUnit?.Id)
+    .map(item => ({ id: String(item.OrgUnit.Id), name: item.OrgUnit.Name || `Course ${item.OrgUnit.Id}`,
+      active: item.Access.IsActive === true }));
+  const allowed = new Map(courses.map(course => [course.id, course]));
+  const assignments = projectAssignments(rows, courses, origin);
+  const assignmentParents = new Set(assignments.map(item => `${item.course}:${item.id}`));
+  const restrictedQuizzes = rows.filter(row => row.category === 'quiz_details' &&
+    (['denied', 'not_configured'].includes(row.outcome) || row.data?.IsHidden || row.data?.IsLocked || row.data?.IsPublished === false));
+  const sources = [];
+  for (const row of rows) {
+    if (!categories.has(row.category) || !allowed.has(String(row.course)) || ['denied', 'not_configured'].includes(row.outcome)) continue;
+    const assignment = row.key?.match(/\/dropbox\/folders\/(\d+)(?:\/|$)/)?.[1] ||
+      (row.category === 'rubrics' ? row.key?.match(/[?&]objectId=(\d+)(?:&|$)/)?.[1] : null);
+    if (assignment && !assignmentParents.has(`${row.course}:${assignment}`)) continue;
+    if (restrictedQuizzes.some(quiz => String(quiz.course) === String(row.course) && row.key?.startsWith(`${quiz.key}/`))) continue;
+    const visit = (value, parentTitle = '', depth = 0, path = '$') => {
+      if (!value || typeof value !== 'object' || depth > 15) return;
+      if (Array.isArray(value)) {
+        for (const [index, item] of value.entries()) {
+          const id = item?.TopicId ?? item?.Id ?? item?.NewsId ?? item?.GradeObjectIdentifier;
+          visit(item, parentTitle, depth + 1, `${path}/${/^\d+$/.test(String(id)) ? `id${id}` : index}`);
+        }
+        return;
+      }
+      if (value.IsHidden || value.IsLocked || value.IsDeleted || value.IsPublished === false ||
+        Date.parse(value.StartDateTime) > Date.now() || Date.parse(value.EndDateTime) < Date.now() ||
+        (row.category === 'announcements' && (Date.parse(value.StartDate) > Date.now() || Date.parse(value.EndDate) < Date.now()))) return;
+      const title = String(value.Title || value.Name || value.Subject || value.title || parentTitle || row.category.replaceAll('_', ' '));
+      const parts = [];
+      const collect = (item, field, level = 0) => {
+        if (typeof item === 'number') parts.push(`${field}: ${item}`);
+        else if (typeof item === 'string') parts.push(['Html', 'Description', 'Instructions', 'Body', 'Content'].includes(field) ? htmlContent(item).text : item);
+        else if (item && typeof item === 'object' && !Array.isArray(item) && level < 3) {
+          for (const [key, child] of Object.entries(item)) if (textFields.has(key)) collect(child, key, level + 1);
+        }
+      };
+      for (const [key, child] of Object.entries(value)) if (textFields.has(key)) collect(child, key);
+      const text = [...new Set(parts.filter(Boolean))].join('\n').slice(0, 1_000_000);
+      if (text) sources.push({ id: `${row.key}#${path}`, resourceKey: row.key, course: String(row.course),
+        courseName: allowed.get(String(row.course)).name, title, text, category: row.category,
+        lastSuccess: row.last_success, checkedAt: row.checked_at, stale: row.outcome !== 'available',
+        dueDate: ['assignments', 'quizzes', 'quiz_details', 'calendar', 'calendar_occurrences'].includes(row.category) && Number.isFinite(Date.parse(value.DueDate)) ? value.DueDate : null,
+        publishedAt: row.category === 'announcements' ? value.PublishedDate || value.StartDate || null : null,
+        url: `${origin}/d2l/home/${row.course}` });
+      for (const [key, child] of Object.entries(value)) {
+        if (!textFields.has(key) && child && typeof child === 'object') visit(child, title, depth + 1, `${path}/${key}`);
+      }
+    };
+    visit(row.data);
+  }
+  return { courses, sources, assignments, state };
+}
+
+export function homeInventory(inventory, now = Date.now()) {
+  const sources = inventory.sources.map(({ text, ...source }) => ({ ...source, excerpt: text.slice(0, 300),
+    ref: JSON.stringify([source.course, source.category, source.title]) }));
+  return { scope: inventory.scope || 'local-empty', courses: inventory.courses,
+    deadlines: sources.filter(source => Date.parse(source.dueDate) >= now).sort((a, b) => Date.parse(a.dueDate) - Date.parse(b.dueDate)),
+    announcements: sources.filter(source => source.category === 'announcements').sort((a, b) => (Date.parse(b.publishedAt) || 0) - (Date.parse(a.publishedAt) || 0)),
+    sources };
+}
+
+const stopWords = new Set('a an the what when where which who how are is was were do does did i my me we our you your for of to in on at and or about can could would should please find show tell looking today'.split(' '));
+
+export function searchInventory(inventory, query, course = '') {
+  // shortcut: local keyword retrieval only; replace with grounded prompt retrieval when that service exists.
+  const terms = [...new Set(query.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [])].filter(term => !stopWords.has(term));
+  if (query.trim() && !terms.length) return { results: [], total: 0 };
+  const matches = inventory.sources.filter(source => !course || source.course === course).map(source => {
+    const title = `${source.title} ${source.courseName}`.toLowerCase();
+    const body = source.text.toLowerCase();
+    return { source, score: terms.reduce((score, term) => score + (title.includes(term) ? 3 : body.includes(term) ? 1 : 0), 0) };
+  }).filter(item => !terms.length || item.score > 0).sort((a, b) => b.score - a.score);
+  return { total: matches.length, results: matches.slice(0, 30).map(({ source }) => {
+    const lower = source.text.toLowerCase();
+    const first = terms.map(term => lower.indexOf(term)).filter(index => index >= 0);
+    const start = Math.max(0, (first.length ? Math.min(...first) : 0) - 100);
+    const { text, ...metadata } = source;
+    return { ...metadata, excerpt: `${start ? '…' : ''}${text.slice(start, start + 700)}${text.length > start + 700 ? '…' : ''}` };
+  }) };
+}

package/src/ui-demo.mjs

@@ -0,0 +1,36 @@
+import { projectInventory } from './ui-data.mjs';
+
+export function demoInventory() {
+  const stamp = '2026-11-02T14:00:00.000Z';
+  const row = (category, course, data) => ({ key: `demo:${category}:${course}`, category, course,
+    data, outcome: 'available', last_success: stamp, checked_at: stamp });
+  return { ...projectInventory([
+    row('enrollments', null, [
+      { OrgUnit: { Id: 101, Name: 'CISC 121 · Introduction to Computing' }, Access: { CanAccess: true, IsActive: true } },
+      { OrgUnit: { Id: 103, Name: 'ELEC 425 · Signals and Systems' }, Access: { CanAccess: true, IsActive: true } },
+      { OrgUnit: { Id: 102, Name: 'PSYC 100 · Principles of Psychology' }, Access: { CanAccess: true, IsActive: true } },
+    ]),
+    row('assignments', '101', [{ Id: 201, Name: 'Assignment 3 · Recursion', DueDate: '2026-11-09T23:59:00-05:00',
+      Instructions: { Text: 'Implement and test recursive functions. Submit your Python file and a short explanation through onQ. Review the recursion lecture before starting.' } }]),
+    row('syllabus_source', '101', { title: 'Course syllabus', text: 'Assessment: assignments 30%, labs 20%, final exam 50%. Office hours are Tuesday, 2–4 pm. Consult onQ for the current schedule.' }),
+    row('content', '102', { Modules: [{ Title: 'Week 8 · Memory', Topics: [
+      { Title: 'Memory and retrieval', Description: { Text: 'Encoding, working memory, long-term memory, and retrieval practice. Read chapter 8 before the seminar.' } },
+    ] }] }),
+    row('announcements', '102', [{ Title: 'Midterm review session', Body: { Text: 'Bring your questions about memory and learning to the review session on Thursday.' } }]),
+    row('assignments', '102', [{ Id: 203, Name: 'Assignment 2 · Memory journal', DueDate: '2026-11-13T23:59:00-05:00',
+      Instructions: { Text: 'Write a reflection on retrieval practice and your study habits.' } }]),
+    row('assignments', '103', [{ Id: 202, Name: 'Assignment 2 · Filter design', DueDate: '2026-11-12T23:59:00-05:00',
+      Instructions: { Text: 'Design a low-pass filter. Submit a PDF report with your calculations, frequency response plots, and MATLAB code. Review Frequency response before starting.' },
+      Attachments: [{ FileId: 7, FileName: 'Filter specifications.pdf' }] }]),
+    { ...row('rubrics', '103', [{ Name: 'Filter design rubric', Criteria: [
+      { Name: 'Design and calculations', Points: 40, Description: { Text: 'Justify the filter parameters and show your calculations.' } },
+      { Name: 'Validation', Points: 40, Description: { Text: 'Include labelled frequency response plots and discuss the results.' } },
+      { Name: 'Presentation', Points: 20, Description: { Text: 'Use a readable report with reproducible MATLAB code.' } },
+    ] }]), key: '/d2l/api/le/1.93/103/rubrics/?objectType=Dropbox&objectId=202' },
+    { ...row('assignment_file', '103', { text: 'Use a 1 kHz cutoff frequency and a 10 kHz sampling rate. Include the magnitude and phase response.' }),
+      key: '/d2l/api/le/1.93/103/dropbox/folders/202/attachments/7' },
+    { ...row('own_submissions', '103', []), key: '/d2l/api/le/1.93/103/dropbox/folders/202/submissions/mysubmissions/' },
+    row('content', '103', { Title: 'Frequency response', Description: { Text: 'Calculate and plot magnitude and phase. Compare the response against the filter specifications.' } }),
+    row('announcements', '103', [{ Title: 'Assignment 2 clarification', Body: { Text: 'For Assignment 2, include both magnitude and phase plots in your report.' } }]),
+  ], { state: 'demo', updatedAt: stamp }), scope: 'demo' };
+}

package/src/ui-server.mjs

@@ -0,0 +1,161 @@
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { join, extname } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { parseArgs } from 'node:util';
+import { readInventory, searchInventory, homeInventory } from './ui-data.mjs';
+import { demoInventory } from './ui-demo.mjs';
+import { ChatGPT } from './llm.mjs';
+import { assignmentWorkspace } from './assignment-workspace.mjs';
+import { composeTaskWorkspace, validTaskContext, taskCatalogue } from './task-workspace.mjs';
+import { validCanvasContext, validCanvas } from '../ui/canvas-contract.js';
+import { canvasDocument } from './canvas.mjs';
+import { createResearch } from './research.mjs';
+
+const root = fileURLToPath(new URL('../ui/', import.meta.url));
+const mime = { '.html': 'text/html; charset=utf-8', '.css': 'text/css', '.js': 'text/javascript', '.svg': 'image/svg+xml', '.png': 'image/png' };
+
+function signInPage(connected, first = false) {
+  const title = connected ? (first ? "You're using your ChatGPT plan" : 'ChatGPT connected') : 'Sign-in did not complete';
+  const message = connected
+    ? 'Eligible AI requests use your ChatGPT plan. You can manage limits in ChatGPT Settings → Usage.'
+    : 'Return to dd2l and open Settings to try signing in again.';
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="dark"><title>${title} · dd2l</title>
+<link rel="icon" href="/assets/logo.svg" type="image/svg+xml"><link rel="stylesheet" href="/style.css"></head>
+<body class="auth-page"><main class="auth-content" aria-labelledby="auth-heading">
+<a class="auth-brand" href="/" aria-label="dd2l home"><img src="/assets/logo.svg" width="40" height="40" alt=""><span>dd2l</span></a>
+<p class="auth-status">${connected ? 'Account connected' : 'Connection interrupted'}</p>
+<h1 id="auth-heading">${title}</h1><p class="auth-message">${message}</p>
+<a class="auth-return" href="/">${connected && first ? 'Got it — return to dd2l' : 'Return to dd2l'} <span aria-hidden="true">→</span></a>
+${connected ? '<a class="auth-usage" href="https://chatgpt.com/settings/usage" target="_blank" rel="noopener noreferrer">Manage usage in ChatGPT ↗</a>' : ''}
+</main></body></html>`;
+}
+
+export function createUiServer({ demo = false, connector, shutdownSignal, inventoryPath = connector?.store.path || join(process.env.LOCALAPPDATA || '', 'dd2l', 'inventory.sqlite'),
+  llm = demo ? null : new ChatGPT(join(process.env.LOCALAPPDATA || '', 'dd2l')) } = {}) {
+  return createServer(async (req, res) => {
+    const authority = `127.0.0.1:${res.socket.localPort}`;
+    const send = (status, body, type = 'application/json', policy) => {
+      res.writeHead(status, { 'Content-Type': type, 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff',
+        'Referrer-Policy': 'no-referrer', 'Cross-Origin-Resource-Policy': 'same-origin', 'X-Frame-Options': policy ? 'SAMEORIGIN' : 'DENY',
+        'Content-Security-Policy': policy || "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'" });
+      res.end(type === 'application/json' ? JSON.stringify(body) : body);
+    };
+    const callback = req.method === 'GET' && req.url.startsWith('/auth/callback?');
+    if (req.headers.host !== authority || (!callback && ((req.headers.origin && req.headers.origin !== `http://${authority}`) || req.headers['sec-fetch-site'] === 'cross-site'))) {
+      send(403, { error: 'Open dd2l using its local URL.' }); return;
+    }
+    try {
+      const url = new URL(req.url, `http://${authority}`);
+      if (callback) {
+        try {
+          if (!llm || demo) throw new Error('disabled');
+          const result = await llm.callback(url.searchParams);
+          send(200, signInPage(true, result.first), 'text/html; charset=utf-8');
+        } catch { send(400, signInPage(false), 'text/html; charset=utf-8'); }
+        return;
+      }
+      if (url.pathname.startsWith('/api/llm/')) {
+        if (!llm || demo) { send(200, { disabled: true, accounts: [], active: null }); return; }
+        if (req.method === 'GET' && url.pathname === '/api/llm/status') { send(200, await llm.status()); return; }
+        if (req.method === 'GET' && url.pathname === '/api/llm/models') { send(200, await llm.models()); return; }
+        if (req.method !== 'POST') { send(405, { error: 'Use POST for AI actions.' }); return; }
+        if (req.headers.origin !== `http://${authority}` || !/^application\/json(?:;|$)/i.test(req.headers['content-type'] || '')) { send(403, { error: 'AI actions require a local JSON request.' }); return; }
+        const chunks = [];
+        let bytes = 0;
+        for await (const chunk of req) {
+          bytes += chunk.length;
+          if (bytes > (url.pathname === '/api/llm/answer' ? 1_000_000 : 8192)) { send(413, { error: 'Request too large.' }); return; }
+          chunks.push(chunk);
+        }
+        let data;
+        try { data = JSON.parse(Buffer.concat(chunks).toString('utf8')); } catch { send(400, { error: 'Invalid JSON.' }); return; }
+        if (!data || typeof data !== 'object' || Array.isArray(data)) { send(400, { error: 'Invalid request.' }); return; }
+        if (['login', 'select'].includes(url.pathname.split('/').at(-1)) && data.id !== undefined && (typeof data.id !== 'string' || data.id.length > 300)) { send(400, { error: 'Invalid account.' }); return; }
+        if (url.pathname === '/api/llm/login') send(200, await llm.login(`http://${authority}/auth/callback`, data.id));
+        else if (url.pathname === '/api/llm/select') send(200, await llm.select(data.id));
+        else if (url.pathname === '/api/llm/logout') send(200, await llm.logout());
+        else if (url.pathname === '/api/llm/answer') {
+          const { q, course = '', assignment = '', context = null, canvas = null, model, consent } = data;
+          if (typeof q !== 'string' || !q.trim() || q.length > 500 || typeof course !== 'string' || (course && !/^\d+$/.test(course)) || typeof model !== 'string' || !model || model.length > 200 || consent !== true) {
+            send(400, { error: 'Provide a question, course, model and permission to share coursework and workspace progress with OpenAI.' }); return;
+          }
+          if (typeof assignment !== 'string' || (assignment && (!/^\d+$/.test(assignment) || !course))) { send(400, { error: 'Invalid assignment context.' }); return; }
+          if (!validTaskContext(context)) { send(400, { error: 'Invalid workspace context.' }); return; }
+          if (!validCanvasContext(canvas)) { send(400, { error: 'Invalid canvas state.' }); return; }
+          const inventory = readInventory(inventoryPath);
+          if (course && !inventory.courses.some(c => c.id === course)) { send(404, { error: 'Course is not available in this inventory.' }); return; }
+          const controller = new AbortController();
+          const abort = () => controller.abort();
+          res.on('close', abort);
+          try {
+            const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(300_000), ...(shutdownSignal ? [shutdownSignal] : [])]);
+            const research = createResearch({ connector, inventoryPath, scope: course, accountScope: inventory.scope || '', signal });
+            const task = await composeTaskWorkspace(llm, inventory, q, model, course, context, signal,
+              () => readInventory(inventoryPath), research);
+            if (task.workspace.question) { send(200, task); return; }
+            try {
+              const generated = await llm.generateCanvas(`Goal: ${task.workspace.goal}\nCurrent request: ${q}`, model, task.sources, canvas, signal);
+              if (!validCanvas(generated)) throw new Error('Invalid generated canvas');
+              send(200, { canvas: generated, answer: generated.answer, ...task });
+            } catch (error) {
+              if (controller.signal.aborted) throw error;
+              send(200, { ...task, answerWarning: error.public ? error.message : 'AI explanation is unavailable. Your selected sources are available below.' });
+            }
+          }
+          finally { res.off('close', abort); }
+        } else send(404, { error: 'Not found.' });
+        return;
+      }
+      if (req.method !== 'GET') { send(405, { error: 'This route is read-only.' }); return; }
+      if (url.pathname.startsWith('/api/')) {
+        if (!['/api/status', '/api/courses', '/api/search', '/api/home', '/api/source'].includes(url.pathname)) { send(404, { error: 'Not found.' }); return; }
+        const query = url.searchParams.get('q') || '';
+        const course = url.searchParams.get('course') || '';
+        const assignment = url.searchParams.get('assignment') || '';
+        if (assignment && (!/^\d+$/.test(assignment) || !course)) { send(400, { error: 'Invalid assignment context.' }); return; }
+        if (query.length > 500 || (course && !/^\d+$/.test(course))) { send(400, { error: 'Use a query of at most 500 characters and a valid course.' }); return; }
+        const inventory = demo ? demoInventory() : readInventory(inventoryPath);
+        if (course && !inventory.courses.some(item => item.id === course)) { send(404, { error: 'Course is not available in this inventory.' }); return; }
+        if (url.pathname === '/api/source') {
+          const id = url.searchParams.get('id') || '';
+          if (!/^[\w-]{24}$/.test(id)) { send(400, { error: 'Invalid source reference.' }); return; }
+          const source = taskCatalogue(inventory, course).find(source => source.id === id);
+          if (!source) { send(404, { error: 'This source is no longer available. Refresh the workspace.' }); return; }
+          send(200, { id: source.id, title: source.title, courseName: source.courseName, text: source.text.slice(0, 100_000),
+            url: source.url, stale: !!source.stale, lastSuccess: source.lastSuccess || null });
+        }
+        else if (url.pathname === '/api/status') send(200, { demo, state: inventory.state,
+          courseCount: inventory.courses.length, sourceCount: inventory.sources.length,
+          lastSuccess: inventory.sources.map(source => source.lastSuccess).filter(Boolean).sort().at(-1) || null });
+        else if (url.pathname === '/api/home') send(200, { ...homeInventory(inventory), demo });
+        else if (url.pathname === '/api/courses') send(200, { courses: inventory.courses });
+        else send(200, { ...searchInventory(inventory, query, course), workspace: query ? assignmentWorkspace(inventory, query, course, assignment) : null, demo });
+        return;
+      }
+      if (url.pathname === '/canvas-frame') {
+        const frame = canvasDocument();
+        send(200, frame.html, 'text/html; charset=utf-8', frame.policy); return;
+      }
+      const path = url.pathname === '/' ? 'index.html' : url.pathname.slice(1);
+      if (!/^(?:index\.html|app\.js|canvas\.js|canvas-contract\.js|widgets\.js|widget-layout\.js|assignment-workspace\.js|answer-view\.js|answer-renderer\.js|loading\.js|style\.css|assets\/[a-z-]+\.(?:svg|png))$/.test(path)) { send(404, { error: 'Not found.' }); return; }
+      send(200, await readFile(join(root, path)), mime[extname(path)]);
+    } catch (error) {
+      send(error.code === 'ENOENT' ? 404 : 503, { error: error.public ? error.message : error.code === 'ENOENT' ? 'Not found.' : 'Local data or AI service is unavailable. Retry after the current operation finishes.' });
+    }
+  });
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const { values } = parseArgs({ options: { demo: { type: 'boolean' }, port: { type: 'string', default: '4173' } } });
+  const port = Number(values.port);
+  if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('Port must be between 1024 and 65535.');
+  if (!values.demo && !process.env.LOCALAPPDATA) throw new Error('Live inventory requires Windows LOCALAPPDATA. Use --demo for sample data.');
+  const controller = new AbortController();
+  const server = createUiServer({ demo: values.demo, shutdownSignal: controller.signal });
+  server.on('error', error => { console.error(`Could not start UI: ${error.code}`); process.exitCode = 1; });
+  server.listen(port, '127.0.0.1', () => console.log(`dd2l ${values.demo ? 'DEMO (sample data)' : '(local cached coursework)'}: http://127.0.0.1:${port}`));
+  for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => { controller.abort(); server.close(); server.closeAllConnections(); });
+}

package/src/windows-ocr.ps1

@@ -0,0 +1,32 @@
+param([Parameter(Mandatory=$true)][string]$ImagePath)
+$ErrorActionPreference = 'Stop'
+try {
+  Add-Type -AssemblyName System.Runtime.WindowsRuntime
+  $null = [Windows.Storage.StorageFile, Windows.Storage, ContentType=WindowsRuntime]
+  $null = [Windows.Graphics.Imaging.BitmapDecoder, Windows.Graphics.Imaging, ContentType=WindowsRuntime]
+  $null = [Windows.Media.Ocr.OcrEngine, Windows.Foundation, ContentType=WindowsRuntime]
+  $asTask = [System.WindowsRuntimeSystemExtensions].GetMethods() | Where-Object { $_.Name -eq 'AsTask' -and $_.GetParameters().Count -eq 1 -and $_.IsGenericMethod -and $_.GetParameters()[0].ParameterType.Name -eq 'IAsyncOperation`1' } | Select-Object -First 1
+  function Await-Result($operation, $resultType) {
+    $task = $asTask.MakeGenericMethod($resultType).Invoke($null, @($operation))
+    $task.Wait()
+    $task.Result
+  }
+  $file = Await-Result ([Windows.Storage.StorageFile]::GetFileFromPathAsync($ImagePath)) ([Windows.Storage.StorageFile])
+  $stream = Await-Result ($file.OpenAsync([Windows.Storage.FileAccessMode]::Read)) ([Windows.Storage.Streams.IRandomAccessStream])
+  try {
+    $decoder = Await-Result ([Windows.Graphics.Imaging.BitmapDecoder]::CreateAsync($stream)) ([Windows.Graphics.Imaging.BitmapDecoder])
+    if ([double]$decoder.PixelWidth * $decoder.PixelHeight -gt 16000000) { throw 'Image pixel limit exceeded' }
+    $maximum = [Windows.Media.Ocr.OcrEngine]::MaxImageDimension
+    $scale = [Math]::Min(1.0, $maximum / [double][Math]::Max($decoder.PixelWidth, $decoder.PixelHeight))
+    $transform = [Windows.Graphics.Imaging.BitmapTransform]::new()
+    $transform.ScaledWidth = [uint32][Math]::Max(1, [Math]::Floor($decoder.PixelWidth * $scale))
+    $transform.ScaledHeight = [uint32][Math]::Max(1, [Math]::Floor($decoder.PixelHeight * $scale))
+    $bitmap = Await-Result ($decoder.GetSoftwareBitmapAsync([Windows.Graphics.Imaging.BitmapPixelFormat]::Bgra8, [Windows.Graphics.Imaging.BitmapAlphaMode]::Ignore, $transform, [Windows.Graphics.Imaging.ExifOrientationMode]::RespectExifOrientation, [Windows.Graphics.Imaging.ColorManagementMode]::DoNotColorManage)) ([Windows.Graphics.Imaging.SoftwareBitmap])
+    try {
+      $engine = [Windows.Media.Ocr.OcrEngine]::TryCreateFromUserProfileLanguages()
+      if ($null -eq $engine) { throw 'OCR language unavailable' }
+      $result = Await-Result ($engine.RecognizeAsync($bitmap)) ([Windows.Media.Ocr.OcrResult])
+      [Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($result.Text)))
+    } finally { $bitmap.Dispose() }
+  } finally { $stream.Dispose() }
+} catch { exit 1 }

package/ui/answer-renderer.js

@@ -0,0 +1,88 @@
+import { validAnswerView } from './answer-view.js';
+
+const element = (tag, text, className) => {
+  const node = document.createElement(tag);
+  if (text !== undefined) node.textContent = text;
+  if (className) node.className = className;
+  return node;
+};
+
+function references(ids, sources) {
+  const links = element('div', undefined, 'answer-references');
+  for (const id of [...new Set(ids)]) {
+    const source = sources[id - 1];
+    const link = element('a', `[${id}]${source.stale ? ' · Stale cache' : ''}`);
+    link.href = `#answer-source-${id}`;
+    link.setAttribute('aria-label', `Source ${id}: ${source.title}${source.stale ? ', stale cache' : ''}`);
+    links.append(link);
+  }
+  return links;
+}
+
+export function renderAnswerView(target, view, sources) {
+  target.replaceChildren();
+  if (!validAnswerView(view, sources.length)) return false;
+  for (const section of view.sections) {
+    const card = element('article', undefined, `widget generated-card answer-${section.type}`);
+    const edition = element('div', undefined, 'widget-edition');
+    edition.append(element('span', { checklist: 'STUDY / CHECKLIST', comparison: 'COURSEWORK / COMPARE', cards: 'SOURCES / COLLECTION' }[section.type]), element('span', 'dd2l'));
+    const header = element('header', undefined, 'widget-header');
+    header.append(element('h3', section.title));
+    card.append(edition, header);
+    if (section.type === 'checklist') {
+      const progress = element('p', `0 of ${section.items.length} complete`, 'answer-progress');
+      progress.setAttribute('role', 'status');
+      const list = element('ul', undefined, 'answer-checklist');
+      let completed = 0;
+      for (const item of section.items) {
+        const row = element('li');
+        const label = element('label');
+        const checkbox = element('input');
+        checkbox.type = 'checkbox';
+        checkbox.addEventListener('change', () => {
+          completed += checkbox.checked ? 1 : -1;
+          row.classList.toggle('completed', checkbox.checked);
+          progress.textContent = `${completed} of ${section.items.length} complete`;
+        });
+        label.append(checkbox, element('span', item.text));
+        row.append(label, references(item.citations, sources));
+        list.append(row);
+      }
+      card.append(progress, list, element('small', 'Checks are kept for this answer only.', 'answer-session-note'));
+    } else if (section.type === 'comparison') {
+      const scroll = element('div', undefined, 'answer-table-scroll');
+      scroll.tabIndex = 0;
+      scroll.setAttribute('role', 'region');
+      scroll.setAttribute('aria-label', section.title);
+      const table = element('table');
+      table.append(element('caption', section.title, 'sr-only'));
+      const head = element('thead'), heading = element('tr');
+      for (const title of [...section.columns, 'Sources']) {
+        const cell = element('th', title); cell.scope = 'col'; heading.append(cell);
+      }
+      head.append(heading);
+      const body = element('tbody');
+      for (const row of section.rows) {
+        const tr = element('tr');
+        for (const [index, value] of row.cells.entries()) {
+          const cell = element(index ? 'td' : 'th', value);
+          if (!index) cell.scope = 'row';
+          tr.append(cell);
+        }
+        const citations = element('td'); citations.append(references(row.citations, sources)); tr.append(citations);
+        body.append(tr);
+      }
+      table.append(head, body); scroll.append(table); card.append(scroll);
+    } else {
+      const list = element('div', undefined, 'answer-source-cards');
+      for (const item of section.cards) {
+        const entry = element('section');
+        entry.append(element('h4', item.title), element('p', item.text), references(item.citations, sources));
+        list.append(entry);
+      }
+      card.append(list);
+    }
+    target.append(card);
+  }
+  return true;
+}

package/ui/answer-view.js

@@ -0,0 +1,47 @@
+const text = (maxLength = 1000) => ({ type: 'string', maxLength });
+const list = (items, maxItems, minItems = 0) => ({ type: 'array', items, minItems, maxItems });
+const object = properties => ({ type: 'object', properties, required: Object.keys(properties), additionalProperties: false });
+const kind = value => ({ type: 'string', enum: [value] });
+const citations = list({ type: 'integer', minimum: 1, maximum: 24 }, 24, 1);
+
+export const answerSchema = object({
+  title: text(160),
+  answer: text(6000),
+  sections: list({ anyOf: [
+    object({ type: kind('checklist'), title: text(160), items: list(object({ text: text(), citations }), 20, 1) }),
+    object({ type: kind('comparison'), title: text(160), columns: list(text(120), 5, 2),
+      rows: list(object({ cells: list(text(), 5, 2), citations }), 20, 1) }),
+    object({ type: kind('cards'), title: text(160), cards: list(object({ title: text(160), text: text(2000), citations }), 12, 1) }),
+  ] }, 6),
+});
+
+// Validate the same bounded schema we send to the provider, including unexpected keys.
+export function matches(value, schema) {
+  if (schema.anyOf) return schema.anyOf.some(choice => matches(value, choice));
+  if (schema.type === 'object') return value !== null && typeof value === 'object' && !Array.isArray(value) &&
+    Object.keys(value).length === schema.required.length && schema.required.every(key => Object.hasOwn(value, key) && matches(value[key], schema.properties[key]));
+  if (schema.type === 'array') return Array.isArray(value) && value.length >= schema.minItems && value.length <= schema.maxItems && value.every(item => matches(item, schema.items));
+  if (schema.type === 'string') return typeof value === 'string' && value.length <= (schema.maxLength ?? Infinity) && (!schema.enum || schema.enum.includes(value));
+  return schema.type === 'integer' && Number.isInteger(value) && value >= schema.minimum && value <= schema.maximum;
+}
+
+export function validAnswerView(value, sourceCount) {
+  if (!matches(value, answerSchema)) return false;
+  return value.sections.every(section => {
+    const items = section.items || section.rows || section.cards;
+    return items.every(item => item.citations.every(id => id <= sourceCount) &&
+      (section.type !== 'comparison' || item.cells.length === section.columns.length));
+  });
+}
+
+export function parseAnswerView(raw, sourceCount) {
+  let value;
+  try { value = JSON.parse(raw); }
+  catch {
+    if (!/^\s*(?:[\[{]|```)/.test(raw)) return { answer: raw, view: null };
+  }
+  if (validAnswerView(value, sourceCount)) return { answer: value.answer, view: value };
+  const answer = typeof value?.answer === 'string' && value.answer.trim() && value.answer.length <= 6000 ? value.answer
+    : 'The model returned an unreadable answer. Please try again.';
+  return { answer, view: null, viewWarning: 'The generated layout could not be verified. Showing text and available sources instead.' };
+}