@joewinke/jatui 0.10.0 → 0.12.0

package/dist/components/VideoPlayer.svelte.d.ts

@@ -2,10 +2,12 @@ export type { VideoChapter, VideoSpeakerTurn, VideoTranscriptSegment, VideoBookm
 export type { BandAxis, BandState } from '../video/band/axis';
 export type { VideoLumaTrack } from '../video/band/luma';
 export type { VideoMarker } from '../video/band/markers';
+export type { NightMode, NightWindow } from '../video/night/clock';
 import type { VideoBookmark, VideoChapter, VideoSpeakerTalkTime, VideoSpeakerTurn, VideoTranscriptSegment, VideoWaveform } from '../video/types';
 import { type BandState } from '../video/band/axis';
 import { type VideoLumaTrack } from '../video/band/luma';
 import { type VideoMarker } from '../video/band/markers';
+import { type NightMode, type NightWindow } from '../video/night/clock';
 type $$ComponentProps = {
     src: string;
     poster?: string | null;
@@ -97,10 +99,49 @@ type $$ComponentProps = {
     onAddBookmark?: (playbackSec: number, label: string) => void;
     /** Right-click on the band. The host owns the panel; this only hit-tests. */
     onBookmarkContext?: (sec: number, existing: VideoBookmark | null, clientX: number, clientY: number) => void;
+    /**
+     * Night dimming (mos-5lzns.33) — a METER, not a preference: ~1×/s while
+     * playing it reads the frame's actual brightness (32×18 canvas) and pulls
+     * the picture down in proportion, warming it through multiply layers so
+     * blacks stay black. A dark scene passes through untouched.
+     *
+     * `'auto'` arms it from the local clock (20:00–07:00; 18:00–08:00 when the
+     * OS prefers dark), `'on'` always, `'off'` never. Omitted (default) ⇒ the
+     * feature does not exist on this player: no N key, no button, no layers.
+     * Bindable — `N` and the moon button cycle it; `onNightModeChange` reports.
+     *
+     * Frame reading needs a CORS-clean load: pass `crossorigin="anonymous"`
+     * for cross-origin media. A tainted canvas runs night on a fixed level
+     * (no meter, no bias light) and calls `onNightBlind`.
+     */
+    night?: NightMode;
+    /** How far night goes, 0.2–1 (default 0.7). Bindable — scrolling the moon button sets it. */
+    nightDepth?: number;
+    /** Override the auto window, local hours `{ from, to }` (wraps midnight when from > to). */
+    nightWindow?: NightWindow | null;
+    /** While night acts, spill the frame's own colours, blurred, behind the player. */
+    biasLight?: boolean;
+    /** Read the `luma` track ~1s ahead so dimming starts BEFORE a bright cut. Only ever adds dimming. */
+    predictive?: boolean;
+    /**
+     * Photosensitivity guard: across the `luma` track's flash intervals,
+     * drop the picture to about 55% brightness (instant in, released per
+     * tick — never a jump back up). Always at full strength: it does NOT
+     * follow `nightDepth`, and it acts whether night is on, off or absent,
+     * whenever the track carries `flashes`. `false` to disable.
+     *
+     * It REDUCES flashes; it does not make content WCAG 2.3.1-safe. Flash
+     * DETECTION is the host's job — the player guards only the intervals the
+     * host supplies in `luma.flashes`.
+     */
+    strobeGuard?: boolean;
+    onNightModeChange?: (mode: NightMode) => void;
+    /** Frame readback was refused (CORS-tainted canvas) — night fell back to a fixed level. */
+    onNightBlind?: () => void;
     class?: string;
 };
 declare const VideoPlayer: import("svelte").Component<$$ComponentProps, {
     bandState: () => BandState;
-}, "">;
+}, "night" | "nightDepth">;
 type VideoPlayer = ReturnType<typeof VideoPlayer>;
 export default VideoPlayer;

package/dist/index.d.ts

@@ -12,7 +12,12 @@ export type { ChapterBlock } from './components/replay/ChapterTimeline.svelte';
 export { default as TranscriptPlayer } from './components/TranscriptPlayer.svelte';
 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 type { VideoChapter, VideoSpeakerTurn, VideoTranscriptSegment, VideoBookmark, VideoWaveform, VideoSpeakerTalkTime, VideoLumaTrack, VideoMarker, BandState, BandAxis, NightMode, NightWindow, } 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

@@ -21,13 +21,18 @@ props + callback surfaces.
 | `deepLink.ts` | .28 (done) | `?t=` parse/format/read/write (replaceState, throttled, other params preserved). |
 | `settings.ts` | shared — knobs added by .30–.34 | `coerce` (never throws, never junk) + `VIDEO_SETTINGS` registry. A knob lands WITH its reader. |
 | `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. |
+| `night.ts` + `night/` | **.33** (done) | `night.ts` is the barrel. `meter.ts` — 32×18 frame bytes → Rec.709 luma + blown share, asymmetric smoothing, bias-light cells from the same bytes. `levels.ts` — luma → brightness/saturation/warmth/vignette off `NIGHT_FLOOR` 0.34, blind fixed level, the light-theme surround. `clock.ts` — local-clock `auto` window + the `N` auto/on/off cycle (no hyprsunset). `track.ts` — prediction (only ever adds dimming), flash intervals, `composeNight` (darker at once, brighter released per tick — never a jump). |
 | `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, };