@joewinke/jatui 0.10.0 → 0.11.0

package/CLAUDE.md

@@ -242,6 +242,16 @@ if (await showConfirm({ title: "Delete?", body: warnBody, danger: true })) { ...
 ## Utilities
 
 ```typescript
+// Video playback advisors (ported from extension-library — mos-5lzns.27).
+// Pure functions: no DOM, no settings reads, never write playbackRate. The
+// player's rate composer / resume-at-sentence / audio-graph tasks consume
+// them; hosts can call them directly too.
+import { buildSilenceMap, boostAt, estimateSaving } from "jatui"      // silence map (smart speed)
+import { speakerPace, suggestRates, rateAt, describeRates } from "jatui" // measured per-speaker wpm
+import { snapResume, resumeLabel } from "jatui"                       // resume at a sentence, never a second
+import { createQuietChain, amountFor } from "jatui"                   // loudness-compensated tone (WebAudio)
+import { qrMatrix, qrCanvas } from "jatui"                            // deep-link QR, ISO 18004 v1–10, no deps
+
 // Date formatting
 import { formatRelativeTime, formatDate, formatShortDate, formatDateTime } from "jatui"
 

package/dist/index.d.ts

@@ -13,6 +13,11 @@ export { default as TranscriptPlayer } from './components/TranscriptPlayer.svelt
 export type { TranscriptSegment, TranscriptBookmark, TranscriptChapter, TranscriptSpeakerTalkTime, } from './components/TranscriptPlayer.svelte';
 export { default as VideoPlayer } from './components/VideoPlayer.svelte';
 export type { VideoChapter, VideoSpeakerTurn, VideoTranscriptSegment, VideoBookmark, VideoWaveform, VideoSpeakerTalkTime, VideoLumaTrack, VideoMarker, BandState, BandAxis, } from './components/VideoPlayer.svelte';
+export { buildSilenceMap, boostAt, estimateSaving, type SilenceMap, type SilenceWave, type SilenceOpts, type BoostOpts } from './video/advisors/smart-speed';
+export { speakerPace, suggestRates, rateAt, describeRates, type SpeakerPace, type SpeakerPaceRow, type RateMap, type RateTurn, type RateSegment, type SuggestOpts } from './video/advisors/speaker-rate';
+export { snapResume, resumeLabel, type ResumePoint, type ResumeReason, type ResumeCtx, type ResumeOpts } from './video/advisors/resume-point';
+export { createQuietChain, amountFor, type QuietChain, type QuietAudioContext, type AmountOpts } from './video/advisors/quiet-listening';
+export { qrMatrix, qrCanvas, type QrMatrix, type QrCanvasOpts } from './video/advisors/qr';
 export { default as Flythrough } from './components/Flythrough.svelte';
 export { default as LessonEmbed } from './components/LessonEmbed.svelte';
 export type { Collection, CollectionCut, CollectionBeat, } from './components/LessonEmbed.svelte';

package/dist/index.js

@@ -13,6 +13,16 @@ export { default as TranscriptPlayer } from './components/TranscriptPlayer.svelt
 // optional so a bare mp4 still gets the full playback UX. TranscriptPlayer
 // stays exported unchanged — meetings already depends on it.
 export { default as VideoPlayer } from './components/VideoPlayer.svelte';
+// Pure advisors (mos-5lzns.27): the extension-library self-test modules,
+// ported verbatim. They measure and advise; the player's feature tasks
+// (.31 audio / .32 rate / .34 presence) consume them. qrCanvas is the one
+// DOM-touching surface (its only guard is a missing document), everything
+// else is node-testable pure.
+export { buildSilenceMap, boostAt, estimateSaving } from './video/advisors/smart-speed';
+export { speakerPace, suggestRates, rateAt, describeRates } from './video/advisors/speaker-rate';
+export { snapResume, resumeLabel } from './video/advisors/resume-point';
+export { createQuietChain, amountFor } from './video/advisors/quiet-listening';
+export { qrMatrix, qrCanvas } from './video/advisors/qr';
 // Presentation-primitive video trio (unified-video-pipeline PRD): the frozen
 // surface academy + mardukos consume. VideoPlayer (above) doubles as the full
 // player AND the presentation player — extended with aspect/autoplay/loop +

package/dist/video/README.md

@@ -23,11 +23,16 @@ props + callback surfaces.
 | `audio.ts` | **.31** | Loudness matching, quiet listening, limiter — audio-graph contract is in the file header. |
 | `night.ts` | **.33** | Night dimming, bias light, predictive dimming (luma track), strobe guard. |
 | `presence.ts` | **.34** | Wind-down (Idle Detection), resume-at-sentence, FLIP open. |
+| `advisors/` | **.27 (done)** | The five extension-library pure advisors, ported verbatim: `smart-speed` (silence map + boost), `speaker-rate` (measured wpm + suggested rates), `resume-point` (sentence-snapping + the label), `quiet-listening` (tone-only chain + `amountFor`), `qr` (ISO 18004 encoder v1–10). Each has its own README row in `advisors/README.md`; the `--self-test` suites live on as vitest in `tests/unit/advisors/` (`npm run test:advisors`). |
 
 Sub-task map: **.30** scrubbing/one-axis/ribbon/markers → `band.ts` (+ its own
 paint layers); **.31** audio graph → `audio.ts`; **.32** rate composer →
 `rate.ts` advisors; **.33** night → `night.ts`; **.34** presence/wind-down →
-`presence.ts`.
+`presence.ts`. **.27** (landed) ports the advisors themselves — .31's chain
+builder and `amountFor` live in `advisors/quiet-listening`, .32's two advisor
+modules in `advisors/smart-speed` + `advisors/speaker-rate`, .34's snapping in
+`advisors/resume-point`; the wiring into the component stays with each
+feature task.
 
 ## The advisor doctrine (from extension-library FEATURES.md — keep it)
 
@@ -43,7 +48,8 @@ paint layers); **.31** audio graph → `audio.ts`; **.32** rate composer →
    MediaElementAudioSourceNode, never the element). Knobs arrive as an
    `opts` argument; a bad argument returns a safe neutral value rather than
    throwing. This is what keeps every module node-testable under
-   `npm run test:unit`.
+   `npm run test:unit` (the advisor vitest suites run under
+   `npm run test:advisors`).
 4. **The rate composer is the shape to follow** (`rate.ts`): `rate = base ×
    speaker × silence`, advisors collapse to 1, the UI reports only `base`.
 
@@ -51,4 +57,12 @@ paint layers); **.31** audio graph → `audio.ts`; **.32** rate composer →
 
 Every pure module gets a `tests/unit/` node:test file (Node ≥ 22.18 strips
 types natively). Canvas/WAAPI work stays out of unit tests by construction —
-that's the point of the split.
+that's the point of the split.
+
+The advisor suites (`.27`) are the one deliberate exception to "node:test":
+they came from the extension's `--self-test` blocks (string-printing PASS/FAIL
+suites with their own helpers), and were ported to **vitest** in
+`tests/unit/advisors/*.test.ts` — run with `npm run test:advisors`. The dir is
+deliberately kept out of `test:unit`'s glob (its script names the node:test
+files explicitly): vitest's `expect()` throws without the vitest process
+around it, so node:test importing these files would fail the wrong runner.

package/dist/video/advisors/README.md

@@ -0,0 +1,20 @@
+/**
+ * Pure advisors for VideoPlayer — ported from extension-library `lib/`
+ * (mos-5lzns.27). Behaviour-verbatim ports of the five self-contained
+ * `--self-test` modules; each `--self-test` suite became a vitest file in
+ * `tests/unit/advisors/`.
+ *
+ * The advisor doctrine (src/lib/video/README.md): these modules measure and
+ * advise, never act. They read no settings, touch no DOM, never write
+ * `playbackRate`, and every function returns a safe neutral value rather than
+ * throwing on malformed input. Knobs arrive as `opts`; the component decides
+ * and applies.
+ *
+ * | Module | Answers | Consumed by |
+ * |---|---|---|
+ * | `smart-speed` | where the silence is, and the boost multiplier inside it | rate composer's `silence` advisor (.32) |
+ * | `speaker-rate` | each speaker's measured wpm, the rates that even them out | rate composer's `speaker` advisor (.32) |
+ * | `resume-point` | the nearest real boundary at-or-before a stored time + the line to say | resume-at-sentence (.34) |
+ * | `quiet-listening` | the loudness-compensated tone graph + how much of it is wanted | audio graph (.31) |
+ * | `qr` | the deep link as a scannable symbol | "continue on phone" (host UI) |
+ */

package/dist/video/advisors/qr.d.ts

@@ -0,0 +1,95 @@
+/**
+ * QR Code (ISO/IEC 18004) encoder: versions 1–10, byte mode, no deps. Ported
+ * verbatim from extension-library `lib/qr.js` (mos-5lzns.27).
+ *
+ * Why hand-rolled. The extension ran under a strict CSP where every CDN-hosted
+ * QR library was unreachable by construction, and there was no build step to
+ * vendor one through. The alternative — pasting a minified blob into the repo —
+ * ships a black box into a codebase whose whole premise is that you can read
+ * it. This is the spec, written out, and PROVEN by the vitest suite that
+ * replaced the `--self-test` block (a reader that decodes our own output, plus
+ * structural assertions against published tables) rather than trusted.
+ *
+ * What it is for: a QR of the current deep link — the player's `?t=` substrate
+ * (video/deepLink.ts) plus the host's own file/URL part — so the video you are
+ * watching moves from the desk to a phone mid-sentence. That URL is 60–120
+ * bytes over a tailnet hostname — a version 3–7 symbol at ECC M. Versions above
+ * 10 would buy capacity this will never use and cost another row in four tables
+ * each, so the ceiling is deliberate and qrMatrix throws at it instead of
+ * quietly growing.
+ *
+ * Guard philosophy, since it cuts both ways here: garbage OPTIONS degrade to
+ * defaults (an unknown ecc string is just "M"), because a slightly
+ * wrong-looking QR still scans. Text that genuinely cannot be represented
+ * THROWS, because the failure mode of the alternative is a symbol that scans
+ * perfectly and sends the phone to a truncated URL — silent, plausible, and
+ * wrong.
+ *
+ *   qrMatrix(text, { ecc = "M", minVersion = 1 }) -> { size, modules }
+ *   qrCanvas(text, { scale = 4, margin = 4, dark, light }) -> HTMLCanvasElement
+ *
+ * The self-test's independent READER (mask/format re-derivation, de-interleave,
+ * round-trip decode) lives with the vitest suite in tests/unit/advisors/ —
+ * deliberately NOT built on the encoder's own reserved map or chosen mask, and
+ * deliberately not shipped in dist.
+ */
+declare const MAX_VERSION = 10;
+declare const MODE_BYTE = 4;
+declare const PAD_BYTES: number[];
+declare const ECC_BITS: Record<string, number>;
+export type EccLevel = "L" | "M" | "Q" | "H";
+declare const BLOCKS: Record<EccLevel, number[][]>;
+declare const TOTAL_CW: number[];
+declare const ALIGN_POS: number[][];
+declare const MASKS: ((r: number, c: number) => boolean)[];
+declare const GF_EXP: Uint8Array<ArrayBuffer>;
+declare const GF_LOG: Uint8Array<ArrayBuffer>;
+declare const gfMul: (a: number, b: number) => number;
+declare function rsGenerator(n: number): number[];
+declare function rsEncode(data: Uint8Array, ecLen: number): Uint8Array;
+declare function rsSyndromes(block: number[], ecLen: number): Uint8Array;
+declare function formatBits(ecc: string, mask: number): number;
+declare function versionBits(version: number): number;
+declare const charCountBits: (version: number) => 8 | 16;
+declare const dataCodewords: (version: number, ecc: EccLevel) => number;
+declare const maxBytes: (version: number, ecc: EccLevel) => number;
+declare function toBytes(text: unknown): Uint8Array;
+declare function encodeData(bytes: Uint8Array, version: number, ecc: EccLevel): Uint8Array;
+declare function interleave(data: Uint8Array, version: number, ecc: EccLevel): Uint8Array;
+interface DrawnPattern {
+    size: number;
+    modules: boolean[][];
+    fn: boolean[][];
+}
+declare function drawFunctionPatterns(version: number): DrawnPattern;
+declare function placeData(modules: boolean[][], fn: boolean[][], size: number, cw: Uint8Array): number;
+declare function drawFormatBits(m: boolean[][], size: number, ecc: string, mask: number): void;
+declare const P3A: number[];
+declare const P3B: number[];
+declare function penalty(m: boolean[][], size: number): number;
+interface BuiltMatrix {
+    size: number;
+    modules: boolean[][];
+    mask: number;
+    version: number;
+    ecc: EccLevel;
+    codewords: Uint8Array;
+}
+declare function buildMatrix(bytes: Uint8Array, version: number, ecc: EccLevel, forcedMask: number | null): BuiltMatrix;
+export interface QrMatrix {
+    /** Module count per side (21 for v1, +4 per version). */
+    size: number;
+    /** size×size grid; true = dark module. */
+    modules: boolean[][];
+}
+export declare function qrMatrix(text: unknown, opts?: unknown): QrMatrix;
+export interface QrCanvasOpts {
+    ecc?: string;
+    minVersion?: number;
+    scale?: number;
+    margin?: number;
+    dark?: string;
+    light?: string;
+}
+export declare function qrCanvas(text: unknown, opts?: QrCanvasOpts | null): HTMLCanvasElement;
+export { MAX_VERSION, MODE_BYTE, PAD_BYTES, ECC_BITS, BLOCKS, TOTAL_CW, ALIGN_POS, MASKS, P3A, P3B, GF_EXP, GF_LOG, gfMul, rsGenerator, rsEncode, rsSyndromes, formatBits, versionBits, charCountBits, dataCodewords, maxBytes, toBytes, encodeData, interleave, drawFunctionPatterns, placeData, drawFormatBits, penalty, buildMatrix, };