@instructure/platform-modules 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# @instructure/platform-modules
+
+The platform modules experience. One data layer and one set of components, driven by a
+host-supplied adapter.
+
+## Installation
+
+Add the workspace dependency:
+
+```json
+{
+  "dependencies": {
+    "@instructure/platform-modules": "workspace:*"
+  }
+}
+```
+
+### Peer dependencies
+
+The host provides React 18, `@tanstack/react-query` 5, `graphql` 16, `zod` 3, and the InstUI 11
+packages listed under `peerDependencies` in `package.json`.
+
+## Usage
+
+Build an adapter once, outside render. Wrap the page in the i18n provider. Call the hook and pass
+its whole result to the list.
+
+```tsx
+import {
+  createCanvasGraphqlAdapter,
+  ModulesI18nProvider,
+  ModulesList,
+  useModulesPageData,
+} from '@instructure/platform-modules'
+
+const adapter = createCanvasGraphqlAdapter({ executeQuery })
+
+function ModulesPage({ courseId }: { courseId: string }) {
+  const data = useModulesPageData({ courseId, adapter, view: 'student' })
+  return (
+    <ModulesI18nProvider t={t} locale={locale}>
+      <ModulesList data={data} courseName={courseName} />
+    </ModulesI18nProvider>
+  )
+}
+```
+
+Keep the adapter referentially stable. A new adapter identity on every render rebuilds every item
+observer's options on every render.
+
+## Adapters
+
+| Adapter | Use |
+|---|---|
+| `createCanvasGraphqlAdapter({ executeQuery })` | Canvas GraphQL. The host injects `executeQuery` |
+| `createInMemoryAdapter({ fixture })` | Tests, stories, and the demo app |
+
+`executeQuery` is a constructor argument, not a context read, so each host supplies its own
+endpoint and auth for the same documents.
+
+## Development
+
+```bash
+pnpm --filter @instructure/platform-modules test
+pnpm --filter @instructure/platform-modules type-check
+pnpm --filter @instructure/platform-modules build
+pnpm storybook
+```
+
+## Documentation
+
+- `CLAUDE.md` describes what is true in `src/` right now.
+- `docs/adr/` holds the decision records. They are append-only: supersede a record, never edit it.
+- Reasoning local to one file stays in a doc comment there. Start with `adapters/types.ts`,
+  `adapters/limits.ts`, `hooks/constants.ts`, and `cache/invalidate.ts`.

package/dist/adapters/canvasGraphql/index.d.ts

@@ -0,0 +1,54 @@
+import { ModulesDataAdapter } from '../types';
+import { UnsupportedModuleItem } from './normalize';
+/**
+ * The Canvas GraphQL implementation of `ModulesDataAdapter`.
+ *
+ * `executeQuery` is injected rather than pulled from `usePlatformUi()`. Two
+ * reasons, both load-bearing: the adapter stays a plain function that a test
+ * can drive with `vi.fn()` and no React, and it stays host-agnostic — Canvas
+ * Career supplies a different `executeQuery` (different endpoint, different
+ * auth) for the identical documents.
+ */
+export type ExecuteQuery = <TResult, TVariables>(query: unknown, variables: TVariables) => Promise<TResult>;
+export { INLINE_ITEM_LIMIT, INLINE_QUERY_NODE_BUDGET } from '../limits';
+export interface CanvasGraphqlAdapterOptions {
+    executeQuery: ExecuteQuery;
+    /** @see INLINE_ITEM_LIMIT */
+    inlineItemLimit?: number;
+    /** @see INLINE_QUERY_NODE_BUDGET */
+    nodeBudget?: number;
+    /**
+     * Notified when an item is dropped for having a content type outside the
+     * closed domain enum. Unset by default: dropping is the deliberate policy,
+     * this is the seam for making it visible.
+     */
+    onUnsupportedItem?: (item: UnsupportedModuleItem) => void;
+    /**
+     * The student whose submissions to select, when there is one.
+     *
+     * Omit for a teacher, an admin, an observer, or any viewer without a single
+     * subject. Omitting it is *safe by construction*: the submission field set is
+     * then not requested at all, so `ModuleItem.status` comes back undefined —
+     * already the contract's "not fetched" — rather than filled with somebody
+     * else's data.
+     *
+     * Supplying it is what makes per-item status available, and it must be the
+     * viewer's own id. Canvas's `submissionsConnection` returns *every* visible
+     * student's submissions to a viewer holding `manage_grades` or
+     * `view_all_grades`, ordered by `user_id`. @see the `SUBMISSION_FIELDS`
+     * docstring in `./queries`.
+     */
+    studentId?: string | null;
+    /**
+     * Validate normalised output against the Zod schemas before returning.
+     *
+     * On by default. This is the check that keeps the GraphQL and REST adapters
+     * from drifting, and it is the only place the contract is enforced at
+     * runtime — turn it off only if a profile says it costs something real.
+     */
+    validate?: boolean;
+}
+export declare function createCanvasGraphqlAdapter({ executeQuery, inlineItemLimit, nodeBudget, onUnsupportedItem, studentId, validate, }: CanvasGraphqlAdapterOptions): ModulesDataAdapter;
+export { GET_MODULE_ITEMS, GET_MODULES, type GetModuleItemsVariables, type GetModulesVariables, } from './queries';
+export { buildStudentContext, deriveModuleItemStatus, deriveModuleProgress, deriveModuleStatus, firstSubmission, type GetModuleItemsResult, type GetModulesResult, type GraphqlCompletionRequirement, type GraphqlModuleConnection, type GraphqlModuleItemConnection, type GraphqlModuleItemContent, type GraphqlModuleItemNode, type GraphqlModuleNode, type GraphqlModuleProgression, type GraphqlModuleStatistics, type GraphqlPageInfo, type GraphqlRequirement, type GraphqlSubmission, type GraphqlSubmissionConnection, type ModuleStudentContext, normalizeItemType, normalizeModule, normalizeModuleItem, normalizeModuleItemsPage, normalizeModulesPage, normalizePageInfo, type NormalizeOptions, PartialCanvasResponseError, type PartialResponseSubject, parseDurationMinutes, type UnsupportedModuleItem, } from './normalize';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/canvasGraphql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/canvasGraphql/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAwC,kBAAkB,EAAE,MAAM,UAAU,CAAA;AACxF,OAAO,EAKL,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAA;AAQpB;;;;;;;;GAQG;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,UAAU,EAC7C,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,UAAU,KAClB,OAAO,CAAC,OAAO,CAAC,CAAA;AAUrB,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAA;AAEvE,MAAM,WAAW,2BAA2B;IAC1C,YAAY,EAAE,YAAY,CAAA;IAC1B,6BAA6B;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,oCAAoC;IACpC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,CAAA;IACzD;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AA6BD,wBAAgB,0BAA0B,CAAC,EACzC,YAAY,EACZ,eAAmC,EACnC,UAAqC,EACrC,iBAAiB,EACjB,SAAS,EACT,QAAe,GAChB,EAAE,2BAA2B,GAAG,kBAAkB,CAgFlD;AAED,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,GACzB,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,2BAA2B,EAChC,KAAK,oBAAoB,EACzB,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,0BAA0B,EAC1B,KAAK,sBAAsB,EAC3B,oBAAoB,EACpB,KAAK,qBAAqB,GAC3B,MAAM,aAAa,CAAA"}

package/dist/adapters/canvasGraphql/normalize.d.ts

@@ -0,0 +1,345 @@
+import { CompletionRequirement, CompletionRequirementType, Module, ModuleItem, ModuleItemsPage, ModuleItemStatus, ModuleItemType, ModuleProgress, ModulesPage, ModuleStatus, PageInfo } from '../../types/domain';
+/**
+ * GraphQL node → domain model.
+ *
+ * Everything transport-shaped stops here. The three normalisation rules from
+ * `types/domain.ts` are enforced in this file and nowhere else:
+ *
+ *   1. **Ids are strings.** Canvas hands back `ID`, which the JSON transport
+ *      may render as a number; every id goes through `String()`.
+ *   2. **`published` is always populated.** On this transport Canvas's resolver
+ *      cannot return null for any viewer, so a null is a partial response and
+ *      throws — see `resolvePublished`, which explains why the REST rule about
+ *      absence meaning "published" does not apply here.
+ *   3. **One closed item enum.** `__typename` is the discriminator, with
+ *      `Assignment { isNewQuiz: true }` collapsing to `'quiz'`.
+ */
+export interface GraphqlPageInfo {
+    hasNextPage: boolean;
+    endCursor: string | null;
+}
+export interface GraphqlCompletionRequirement {
+    id: string | number;
+    type: string;
+    minScore?: number | null;
+    minPercentage?: number | null;
+}
+/** One row of `submissionsConnection`. Present only for a student viewer. */
+export interface GraphqlSubmission {
+    _id?: string | number | null;
+    /** `SubmissionState`: unsubmitted | submitted | pending_review | graded | ungraded | deleted. */
+    state?: string | null;
+    /** `SubmissionGradingStatus`: needs_grading | needs_review | graded | excused. */
+    gradingStatus?: string | null;
+    submittedAt?: string | null;
+    attempt?: number | null;
+    missing?: boolean | null;
+    /** Per-student, override-applied due date, denormalised onto the submission. */
+    cachedDueDate?: string | null;
+}
+export interface GraphqlSubmissionConnection {
+    nodes?: (GraphqlSubmission | null)[] | null;
+}
+export interface GraphqlModuleItemContent {
+    __typename?: string | null;
+    isNewQuiz?: boolean | null;
+    dueAt?: string | null;
+    /** Declared on `ModuleItemInterface`; `null` for content that cannot be graded. */
+    pointsPossible?: number | null;
+    submissionsConnection?: GraphqlSubmissionConnection | null;
+}
+/** A `Requirement` as it appears in `ModuleProgression.requirementsMet`. */
+export interface GraphqlRequirement {
+    id: string | number;
+    type: string;
+    minScore?: number | null;
+    minPercentage?: number | null;
+}
+export interface GraphqlModuleProgression {
+    /** locked | unlocked | started | completed. */
+    workflowState?: string | null;
+    completed?: boolean | null;
+    locked?: boolean | null;
+    started?: boolean | null;
+    requirementsMet?: (GraphqlRequirement | null)[] | null;
+}
+/** `Module.submissionStatistics`, i.e. Canvas's `ModuleStatistics`. */
+export interface GraphqlModuleStatistics {
+    latestDueAt?: string | null;
+    missingAssignmentCount?: number | null;
+}
+export interface GraphqlModuleItemNode {
+    _id: string | number;
+    title?: string | null;
+    url?: string | null;
+    position?: number | null;
+    indent?: number | null;
+    published?: boolean | null;
+    /** ISO 8601 duration, e.g. `PT45M`. Canvas Career only. */
+    estimatedDuration?: string | null;
+    content?: GraphqlModuleItemContent | null;
+}
+export interface GraphqlModuleItemConnection {
+    nodes?: (GraphqlModuleItemNode | null)[] | null;
+    pageInfo: GraphqlPageInfo;
+}
+export interface GraphqlModuleNode {
+    _id: string | number;
+    name?: string | null;
+    position?: number | null;
+    published?: boolean | null;
+    unlockAt?: string | null;
+    /**
+     * `Int!` in the Canvas schema, so it is optional here only because a partial
+     * response can omit it. `normalizeModule` treats that as a hard error rather
+     * than a zero — see `PartialCanvasResponseError`.
+     */
+    moduleItemsTotalCount?: number | null;
+    requirementCount?: number | null;
+    requireSequentialProgress?: boolean | null;
+    prerequisites?: ({
+        id: string | number;
+    } | null)[] | null;
+    completionRequirements?: (GraphqlCompletionRequirement | null)[] | null;
+    /** Absent for a teacher/anonymous viewer, and `null` when Canvas has none. */
+    progression?: GraphqlModuleProgression | null;
+    submissionStatistics?: GraphqlModuleStatistics | null;
+    moduleItemsConnection?: GraphqlModuleItemConnection | null;
+}
+export interface GraphqlModuleConnection {
+    nodes?: (GraphqlModuleNode | null)[] | null;
+    pageInfo: GraphqlPageInfo;
+}
+export interface GetModulesResult {
+    legacyNode?: {
+        modulesConnection?: GraphqlModuleConnection | null;
+    } | null;
+}
+export interface GetModuleItemsResult {
+    legacyNode?: {
+        completionRequirements?: (GraphqlCompletionRequirement | null)[] | null;
+        progression?: GraphqlModuleProgression | null;
+        moduleItemsConnection?: GraphqlModuleItemConnection | null;
+    } | null;
+}
+/** What a `PartialCanvasResponseError` is about. */
+export type PartialResponseSubject = 'module' | 'moduleItem';
+/**
+ * A row arrived without a field this adapter cannot responsibly guess.
+ *
+ * Thrown rather than defaulted, because in both current cases the
+ * sensible-looking default is the dangerous one:
+ *
+ *   - `moduleItemsTotalCount` is `Int!`. Coercing a missing value to `0` makes
+ *     `resolveItemsMode` see an empty course and answer `inline`, so the page
+ *     asks Canvas to inline every item it has — the most expensive transport
+ *     setting, chosen when the response is least trustworthy.
+ *   - `published` is null when the viewer cannot manage the object, which for
+ *     such a viewer means "published". For a viewer who *can* manage, Canvas
+ *     always sends a boolean, so a null contradicts what the host told us and
+ *     the wrong guess renders an unpublished thing as published — to the one
+ *     audience that acts on that badge.
+ *
+ * Failing is recoverable in a way silence is not: the hook surfaces the error,
+ * the host can retry, and `useItemsMode` already falls through to `onDemand` on
+ * a failed probe rather than deadlocking the page.
+ */
+export declare class PartialCanvasResponseError extends Error {
+    readonly subject: PartialResponseSubject;
+    /** The module or item id, so a host can log which row came back incomplete. */
+    readonly id: string;
+    /** The field that was missing. */
+    readonly field: string;
+    constructor(subject: PartialResponseSubject, id: string, field: string);
+}
+/** Reported when a `__typename` has no place in the closed domain enum. */
+export interface UnsupportedModuleItem {
+    /** The module item id, so a host can look the row up in Canvas. */
+    id: string;
+    /** The `content.__typename` we could not map, or `null` when content was absent. */
+    typename: string | null;
+}
+export interface NormalizeOptions {
+    /**
+     * Called for every item dropped because its content type is outside the
+     * closed enum (`AiExperience`, `PeerReviewSubAssignment`, or content that
+     * was deleted and came back `null`).
+     *
+     * The alternatives were worse: widening the enum makes the shared contract
+     * chase Canvas's release cadence, and throwing takes the whole page down for
+     * one unknown row.
+     *
+     * Dropping is silent data loss, so it must not *also* be unobservable. This
+     * defaults to a `console.warn` rather than to nothing — matching
+     * `platform-datetime` and ~30 other files in the repo — because "a host can log
+     * it" is only true if the host knows to opt in. Pass a no-op to silence it.
+     */
+    onUnsupportedItem?: (item: UnsupportedModuleItem) => void;
+}
+/**
+ * `__typename` (+ `isNewQuiz`) → domain type, or `null` when unmappable.
+ *
+ * A New Quiz is an `Assignment` with an LTI submission type in Canvas's data
+ * model; every UI that shows it calls it a quiz, so rule 3 collapses it here
+ * rather than leaving each caller to re-derive it.
+ */
+export declare function normalizeItemType(content: GraphqlModuleItemContent | null | undefined): ModuleItemType | null;
+/**
+ * ISO 8601 duration → whole minutes.
+ *
+ * Canvas exposes `estimatedDuration` as an `ISO8601Duration` scalar (`PT45M`)
+ * while the domain model carries minutes, because that is the only unit either
+ * host's UI renders. Year and month designators are rejected rather than
+ * guessed at — they are not calendar-independent, and Canvas never emits them
+ * for this field.
+ */
+export declare function parseDurationMinutes(value: string | null | undefined): number | null;
+/**
+ * Wire string → closed enum, with anything unrecognised becoming `'unknown'`.
+ *
+ * Unlike an unmappable item `__typename`, an unknown requirement type is not
+ * dropped: the requirement still exists, the student still has to satisfy it,
+ * and hiding the row would be a worse lie than labelling it vaguely.
+ */
+export declare function normalizeCompletionRequirementType(type: string): CompletionRequirementType;
+export declare function normalizePageInfo(pageInfo: GraphqlPageInfo | null | undefined): PageInfo;
+/**
+ * The module-level student state every item in that module is read against.
+ *
+ * Built once per module and threaded into the item normaliser so the inline and
+ * on-demand paths derive the identical status for the identical item — which is
+ * why `GET_MODULE_ITEMS` re-reads `progression` alongside its items.
+ */
+export interface ModuleStudentContext {
+    /** Canvas reports the module locked for this student. */
+    locked: boolean;
+    /** Raw `ModuleProgression.workflowState`: locked | unlocked | started | completed. */
+    workflowState: string | null;
+    completed: boolean;
+    started: boolean;
+    /**
+     * Module *item* ids whose completion requirement the student has satisfied.
+     *
+     * `ModuleProgression.requirementsMet` is a list of `Requirement`, and
+     * `Requirement.id` is the module item id — the same join `completionRequirements`
+     * uses. The domain model wants a count, so the list collapses here.
+     */
+    requirementsMetItemIds: ReadonlySet<string>;
+}
+/**
+ * The student's submission for an item, or `null`.
+ *
+ * Canvas returns a connection because the field is shared with the teacher view
+ * (where it is every student's submission); for a student it holds at most one
+ * row, so the first non-null node is the answer.
+ */
+export declare function firstSubmission(content: GraphqlModuleItemContent | null | undefined): GraphqlSubmission | null;
+/**
+ * `progression` → the per-module student context, or `undefined` when there is
+ * no student. This is the gate described at the top of this block.
+ *
+ * `requirementsMet` is filtered against the requirements the module currently
+ * defines, matching Canvas's own `filterRequirementsMet`: a progression can
+ * outlive the requirement that produced it, and counting a stale entry would
+ * show a student 4 of 3. Canvas matches on id, type, `minScore` *and*
+ * `minPercentage`; we match on id and type only, because the score bounds are
+ * the part a teacher edits in place and an edited bound should not silently
+ * un-meet a requirement the student genuinely satisfied.
+ */
+export declare function buildStudentContext(progression: GraphqlModuleProgression | null | undefined, completionRequirements: readonly CompletionRequirement[]): ModuleStudentContext | undefined;
+/**
+ * Per-item status. First rule that matches wins:
+ *
+ *   1. `locked`      — the module is locked for this student. Canvas exposes no
+ *                      per-item lock in this field set (`masteryPaths.locked` is
+ *                      a host-specific affordance we deliberately do not fetch),
+ *                      and a locked module is locked for every item in it.
+ *   2. `missing`     — `submission.missing`. Ahead of `graded` on purpose: this
+ *                      is the precedence Canvas's own student pill uses, and a
+ *                      teacher entering a zero on a missing submission should
+ *                      not make the "Missing" chip stop finding it.
+ *   3. `graded`      — `state === 'graded'`, or `gradingStatus` is `graded`/
+ *                      `excused`. Excused counts as graded because there is
+ *                      nothing left for the student to do.
+ *   4. `submitted`   — handed in and awaiting a grade: `submittedAt` is set, or
+ *                      the state is `submitted`/`pending_review`.
+ *   5. `in_progress` — the student has engaged but produced nothing gradable:
+ *                      either an attempt is open (`attempt > 0` with no
+ *                      `submittedAt`), or the item's completion requirement is
+ *                      already met with no submission at all — a viewed page, a
+ *                      followed link, a contribution to an ungraded discussion.
+ *   6. `not_started` — everything else.
+ *
+ * Rule 5 is the one to argue with. `ModuleItemStatus` has no "complete" member,
+ * so a satisfied `must_view` requirement has nowhere else to land; the domain
+ * comment already flags the same gap at module level ("All items complete" is
+ * not in the designer's list). If the designer adds one, this is the rule to
+ * change and the only one.
+ */
+export declare function deriveModuleItemStatus(content: GraphqlModuleItemContent | null | undefined, itemId: string, student: ModuleStudentContext): ModuleItemStatus;
+/**
+ * Per-module rollup. First rule that matches wins:
+ *
+ *   1. `locked`        — `progression.locked` (or `workflowState === 'locked'`).
+ *   2. `missing`       — `submissionStatistics.missingAssignmentCount > 0` and
+ *                        the module is not completed. That is the design's
+ *                        "1+ item past due", read from the module-level
+ *                        statistic rather than from items, so the filter row
+ *                        works with nothing expanded.
+ *   3. `all_graded`    — completed, *and* items were fetched, *and* every
+ *                        gradable one is `graded`.
+ *   4. `all_submitted` — completed. The honest floor: `progression.completed`
+ *                        means every requirement is met, which is submission,
+ *                        not grading. See the caveat below.
+ *   5. `in_progress`   — started, or at least one requirement met.
+ *   6. `not_started`   — everything else.
+ *
+ * Caveat on rule 3: Canvas has no module-level "everything is graded" signal —
+ * `ModuleStatistics` is only `latestDueAt` + `missingAssignmentCount`. So
+ * `all_graded` is reachable **only in inline mode**, where the items ride along
+ * with the module in the same response. Upgrading on the evidence we have beats
+ * claiming a grade we cannot see.
+ *
+ * In `onDemand` mode a completed module reports `all_submitted` and stays there,
+ * even after its items are fetched and every one of them is `graded`. That is a
+ * real limitation, not a temporary state: `progress` is derived once, from the
+ * list response, and nothing merges items back into it —
+ * `normalizeModuleItemsPage` returns `{ items, pageInfo }` and `useModulesPageData`
+ * never revisits the module. No upgrade to `all_graded` ever happens.
+ *
+ * Closing it means either recomputing the module's status in the UI from the items
+ * it holds — which reintroduces the inline/onDemand asymmetry the module-level
+ * design exists to avoid — or Canvas exposing the signal. Left open deliberately
+ * rather than papered over.
+ */
+export declare function deriveModuleStatus(student: ModuleStudentContext, missingCount: number, requirementsMet: number, items: ModuleItem[] | undefined): ModuleStatus;
+/**
+ * The module's `ModuleProgress`, or `undefined` when there is no student.
+ *
+ * `requirementCount` is the module's own when Canvas set one and the number of
+ * completion requirements otherwise — Canvas uses `requirement_count` for
+ * "complete any N of these", so it is the denominator whenever it is present,
+ * and the full list is the denominator when it is not. `requirementsMet` is
+ * clamped to it so the pair can never read "3 of 1", and `percentComplete` is
+ * derived from that same clamped pair rather than computed independently, so a
+ * host can never render a bar that disagrees with the fraction beside it.
+ */
+export declare function deriveModuleProgress(node: GraphqlModuleNode, completionRequirements: readonly CompletionRequirement[], student: ModuleStudentContext | undefined, items: ModuleItem[] | undefined): ModuleProgress | undefined;
+/**
+ * A single item, or `null` when its content type is outside the closed enum.
+ *
+ * `dueAt` prefers `submission.cachedDueDate` — the per-student, override-applied
+ * date Canvas denormalises onto the submission row — and falls back to
+ * `content.dueAt`. That ordering is what closes the gap a live-Canvas probe
+ * found: `dueAt` exists on `Assignment` only, `Quiz` has none, and a graded
+ * `Discussion` keeps its date on the backing assignment, but all three carry a
+ * submission. The fallback still matters, because a teacher viewer gets an
+ * assignment's `dueAt` and no submission at all.
+ *
+ * `status` is present only when `student` is — see the student-state block.
+ */
+export declare function normalizeModuleItem(node: GraphqlModuleItemNode, moduleId: string, completionRequirementsByItemId: ReadonlyMap<string, CompletionRequirement>, options?: NormalizeOptions, student?: ModuleStudentContext): ModuleItem | null;
+export declare function normalizeModule(node: GraphqlModuleNode, options?: NormalizeOptions): Module;
+export declare function normalizeModulesPage(result: GetModulesResult | null | undefined, options?: NormalizeOptions): ModulesPage;
+export declare function normalizeModuleItemsPage(result: GetModuleItemsResult | null | undefined, moduleId: string, options?: NormalizeOptions): ModuleItemsPage;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/adapters/canvasGraphql/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/adapters/canvasGraphql/normalize.ts"],"names":[],"mappings":"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"}

package/dist/adapters/canvasGraphql/queries.d.ts

@@ -0,0 +1,69 @@
+import { DocumentNode } from 'graphql';
+/**
+ * Module list, optionally with each module's items inlined.
+ *
+ * `includeItems` is expressed as an `@include` directive on the nested
+ * `moduleItemsConnection` rather than as a second document. Reasoning:
+ *
+ *   1. One document means one operation name, which means one persisted-query
+ *      hash to register with Canvas. Two documents would double that
+ *      registration surface for what is a single conceptual read.
+ *   2. The directive is evaluated server-side, so `includeItems: false` skips
+ *      resolving every per-item field — the title, content type, points and
+ *      submissions for each row.
+ *
+ *      What it does *not* skip is the
+ *      `ModuleItemsVisibleLoader`. `moduleItemsTotalCount` and
+ *      `completionRequirements` are selected unconditionally and
+ *      `module_type.rb:137-141,166-169` resolves both through that same loader,
+ *      so it runs whatever `includeItems` is. The saving is per-item field
+ *      resolution, not the visibility query.
+ *   3. The response type is a single shape with an optional key, which is
+ *      exactly how the domain model already treats it (`items?: ModuleItem[]`,
+ *      where `undefined` means "not fetched"). A second document would force
+ *      the normaliser to branch on which document produced the payload.
+ *
+ * `itemsFirst` bounds the inline item fetch. When a module has more items than
+ * that, the normaliser drops the partial list rather than reporting a
+ * truncated one — see `normalize.ts`.
+ */
+export declare const GET_MODULES: DocumentNode;
+/**
+ * A single module's items, paged on demand.
+ *
+ * `completionRequirements` is re-read at the module level here because a
+ * requirement is stored on the module, keyed by item id — without it, items
+ * fetched on demand would lose the requirement that items fetched inline keep,
+ * and the two paths would produce different domain objects for the same item.
+ *
+ * `progression` is re-read for the same reason: `ModuleItem.status` depends on
+ * module-level state (is the module locked for me, which of its requirements
+ * have I met), so an item fetched on demand would otherwise carry a different
+ * status from the identical item fetched inline.
+ */
+export declare const GET_MODULE_ITEMS: DocumentNode;
+export interface GetModulesVariables {
+    courseId: string;
+    first: number;
+    after?: string | null;
+    includeItems: boolean;
+    itemsFirst: number;
+    /**
+     * Whether to select per-item submissions at all.
+     *
+     * False unless a `studentId` is known. Canvas's `submissionsConnection` is
+     * *not* self-scoping for a privileged viewer — see the fragment docstring — so
+     * the safe default is to ask for nothing.
+     */
+    includeSubmissions: boolean;
+    /** The student whose submissions to select. Required whenever `includeSubmissions`. */
+    studentId?: string | null;
+}
+export interface GetModuleItemsVariables {
+    moduleId: string;
+    includeSubmissions: boolean;
+    studentId?: string | null;
+    first: number;
+    after?: string | null;
+}
+//# sourceMappingURL=queries.d.ts.map

package/dist/adapters/canvasGraphql/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../src/adapters/canvasGraphql/queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAiL3C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,WAAW,EAAE,YA0DzB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,EAAE,YAiC9B,CAAA;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,YAAY,EAAE,OAAO,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;OAMG;IACH,kBAAkB,EAAE,OAAO,CAAA;IAC3B,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAA;IAChB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB"}

package/dist/adapters/inMemory.d.ts

@@ -0,0 +1,63 @@
+import { Module, ModuleItem } from '../types/domain';
+import { ModulesDataAdapter } from './types';
+/**
+ * An adapter backed by a plain object instead of a network.
+ *
+ * It exists so the hooks can be built and tested without waiting on a real
+ * adapter, but it is not scaffolding — it stays as the test double for hook
+ * tests and as the fastest way to render a modules UI in Storybook with no
+ * server at all.
+ *
+ * It is a real implementation of the contract, deliberately: it paginates with
+ * opaque cursors, honours `AbortSignal`, and declines to inline items for modules
+ * over `INLINE_ITEM_LIMIT` — so hooks written against it meet the same edges
+ * Canvas will hand them, including the one Canvas Career gets wrong.
+ */
+export { INLINE_ITEM_LIMIT } from './limits';
+export interface InMemoryFixture {
+    /**
+     * The course these modules belong to.
+     *
+     * Present so the adapter can *check* it. Without it, `courseId` was
+     * destructured and dropped, which meant one adapter instance served identical
+     * modules for every course id in existence — and since `cache/keys.ts` keys the
+     * query cache by `courseId`, the entire class of bug where it is mis-threaded,
+     * defaulted or collided across courses was unfalsifiable against the package's
+     * primary test double. A hook that hardcoded `courseId: '1'` internally would
+     * have passed every test and every story.
+     */
+    courseId: string;
+    modules: Module[];
+    itemsByModuleId: Record<string, ModuleItem[]>;
+}
+/** What a served request was for. Handed to `onRequest`. */
+export interface InMemoryRequest {
+    operation: 'listModules' | 'listModuleItems';
+    courseId: string;
+    /** Only set for `listModuleItems`. */
+    moduleId?: string;
+}
+export interface InMemoryAdapterOptions {
+    /**
+     * Invoked once per served request. Test hook for asserting exact request
+     * counts, which is how the scaling behaviour is locked in.
+     *
+     * Receives the operation name for the common case, and the full request for
+     * tests that care *which* course or module was asked for.
+     */
+    onRequest?: (operation: 'listModules' | 'listModuleItems', request: InMemoryRequest) => void;
+}
+/**
+ * Thrown when a caller asks this adapter for a course it was not built for.
+ *
+ * A real transport would return that other course's data, or 404. Silently
+ * serving the fixture regardless is the one behaviour that could not happen in
+ * production, so it is the one behaviour the test double must not have.
+ */
+export declare class InMemoryCourseMismatchError extends Error {
+    readonly expected: string;
+    readonly received: string;
+    constructor(expected: string, received: string);
+}
+export declare function createInMemoryAdapter(fixture: InMemoryFixture, options?: InMemoryAdapterOptions): ModulesDataAdapter;
+//# sourceMappingURL=inMemory.d.ts.map

package/dist/adapters/inMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemory.d.ts","sourceRoot":"","sources":["../../src/adapters/inMemory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAgC,MAAM,iBAAiB,CAAA;AAEvF,OAAO,KAAK,EAAwC,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAEvF;;;;;;;;;;;;GAYG;AAIH,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE5C,MAAM,WAAW,eAAe;IAC9B;;;;;;;;;;OAUG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAAA;CAC9C;AAED,4DAA4D;AAC5D,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,aAAa,GAAG,iBAAiB,CAAA;IAC5C,QAAQ,EAAE,MAAM,CAAA;IAChB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,CAAC,SAAS,EAAE,aAAa,GAAG,iBAAiB,EAAE,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;CAC7F;AAED;;;;;;GAMG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;gBAEb,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAS/C;AA4BD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EACxB,OAAO,GAAE,sBAA2B,GACnC,kBAAkB,CAiEpB"}

package/dist/adapters/index.d.ts

@@ -0,0 +1,3 @@
+export type { ListModuleItemsArgs, ListModulesArgs, ModulesDataAdapter } from './types';
+export { createInMemoryAdapter, InMemoryCourseMismatchError, INLINE_ITEM_LIMIT, type InMemoryAdapterOptions, type InMemoryFixture, type InMemoryRequest, } from './inMemory';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,mBAAmB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACvF,OAAO,EACL,qBAAqB,EACrB,2BAA2B,EAC3B,iBAAiB,EACjB,KAAK,sBAAsB,EAC3B,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,YAAY,CAAA"}