reelson 0.7.0

package/skills/reelson-record/scripts/capture.ts

@@ -0,0 +1,190 @@
+/**
+ * Films the page with Chrome's screencast instead of Playwright's video.
+ *
+ * Playwright's recorder writes a fixed 25 fps WebM, so in the 30 fps recording.mp4
+ * scrolling, hovers and UI transitions stutter (one frame in six repeats). The screencast
+ * hands over every frame the compositor paints (up to 60 fps, full device pixels), each
+ * stamped with the time it was painted on this machine's clock — the same clock as the
+ * markers, clicks and cursor log. `frameSchedule` turns those frames into a constant-rate
+ * video: at every instant, the latest frame painted so far, with demo.cut() ranges removed.
+ */
+import type { BrowserContext, CDPSession, Page } from '@playwright/test'
+import { spawn } from 'node:child_process'
+import { mkdirSync, readFileSync } from 'node:fs'
+import { writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+export interface Frame {
+    file: string
+    /** When Chrome painted it: epoch milliseconds. */
+    t: number
+    /** Which page painted it (0 = the first); see `frameSchedule` switches. */
+    page?: number
+}
+
+/** From `t` (epoch ms) on, the video shows `page`. */
+export interface CameraSwitch {
+    t: number
+    page: number
+}
+
+export interface Screencast {
+    /** Stops filming and waits until every frame is on disk. */
+    stop: () => Promise<Frame[]>
+}
+
+/** Starts filming `page`; frames are written into `dir` as they arrive, tagged `pageId`. */
+export async function startScreencast(context: BrowserContext, page: Page, dir: string, pageId = 0, quality = 92): Promise<Screencast> {
+    mkdirSync(dir, { recursive: true })
+    const cdp: CDPSession = await context.newCDPSession(page)
+    const frames: Frame[] = []
+    const writes: Promise<void>[] = []
+    cdp.on('Page.screencastFrame', (event: { data: string; sessionId: number; metadata: { timestamp?: number } }) => {
+        // Ack first: Chrome sends the next frame only after the previous one is acknowledged.
+        cdp.send('Page.screencastFrameAck', { sessionId: event.sessionId }).catch(() => {})
+        const file = resolve(dir, `${pageId ? `p${pageId}-` : ''}f${String(frames.length).padStart(6, '0')}.jpg`)
+        frames.push({ file, t: (event.metadata.timestamp ?? Date.now() / 1000) * 1000, page: pageId })
+        writes.push(writeFile(file, Buffer.from(event.data, 'base64')))
+    })
+    await cdp.send('Page.startScreencast', { format: 'jpeg', quality, everyNthFrame: 1 })
+
+    return {
+        stop: async () => {
+            await cdp.send('Page.stopScreencast').catch(() => {})
+            await Promise.all(writes)
+            await cdp.detach().catch(() => {})
+            return frames
+        },
+    }
+}
+
+/**
+ * How long each frame stays on screen in the finished video (seconds), in order. Video
+ * time 0 is `startedAt` (the recording clock of createDemo); a frame shows from the moment
+ * it was painted until the next one; the first frame also covers anything before it.
+ * `cuts` are ranges of that clock (seconds) left out of the video. With `switches`, only
+ * the page the camera is on counts at each moment (a pop-up, then back to its opener, which
+ * shows its last frame from before); without, every frame counts.
+ */
+export function frameSchedule(
+    frames: Frame[],
+    startedAt: number,
+    endedAt: number,
+    cuts: { from: number; to: number }[],
+    switches?: CameraSwitch[],
+): { file: string; duration: number }[] {
+    const end = (endedAt - startedAt) / 1000
+    const seconds = (t: number) => (t - startedAt) / 1000
+    const camera = switches?.length
+        ? [...switches].sort((a, b) => a.t - b.t).map((s) => ({ at: Math.max(0, seconds(s.t)), page: s.page }))
+        : [{ at: 0, page: -1 }]
+    const pieces = camera.map((c, i) => ({ from: i === 0 ? 0 : c.at, to: i + 1 < camera.length ? camera[i + 1].at : end, page: c.page }))
+    const kept = keptRanges(cuts, end)
+    const out: { file: string; duration: number }[] = []
+    const add = (file: string, from: number, to: number) => {
+        for (const range of kept) {
+            const overlap = Math.min(to, range.to) - Math.max(from, range.from)
+            if (overlap <= 0) {
+                continue
+            }
+            const last = out[out.length - 1]
+            if (last?.file === file) {
+                last.duration += overlap
+            } else {
+                out.push({ file, duration: overlap })
+            }
+        }
+    }
+    for (const piece of pieces.filter((p) => p.to > p.from)) {
+        const own = frames
+            .filter((f) => piece.page === -1 || (f.page ?? 0) === piece.page)
+            .sort((a, b) => a.t - b.t)
+            .map((f) => ({ file: f.file, t: seconds(f.t) }))
+        if (!own.length) {
+            continue
+        }
+        // On screen at the start of the piece: the page's latest frame so far, else its first.
+        let i = Math.max(0, own.findLastIndex((f) => f.t <= piece.from))
+        for (; i < own.length && own[i].t < piece.to; i++) {
+            const from = Math.max(piece.from, own[i].t)
+            const to = Math.min(piece.to, i + 1 < own.length ? own[i + 1].t : piece.to)
+            if (to > from) {
+                add(own[i].file, i === 0 && own[i].t > piece.from ? piece.from : from, to)
+            }
+        }
+    }
+
+    return out
+}
+
+/** [0, end] minus the cuts. */
+function keptRanges(cuts: { from: number; to: number }[], end: number): { from: number; to: number }[] {
+    const ranges: { from: number; to: number }[] = []
+    let at = 0
+    for (const c of [...cuts].sort((a, b) => a.from - b.from)) {
+        if (c.from > at) {
+            ranges.push({ from: at, to: Math.min(c.from, end) })
+        }
+        at = Math.max(at, c.to)
+    }
+    if (at < end) {
+        ranges.push({ from: at, to: end })
+    }
+    return ranges.filter((r) => r.to > r.from)
+}
+
+/** The finished recording's frame rate. */
+export const FPS = 30
+
+/**
+ * Encodes the schedule as the H.264 recording.mp4 HyperFrames consumes: output frame k
+ * (at k / FPS s) is the latest frame painted by then, piped straight into ffmpeg at a
+ * constant rate. (ffmpeg's concat demuxer would snap image timestamps to 25 fps.)
+ */
+export async function encodeFrames(schedule: { file: string; duration: number }[], mp4: string): Promise<boolean> {
+    if (!schedule.length) {
+        return false
+    }
+    const total = schedule.reduce((sum, e) => sum + e.duration, 0)
+    const count = Math.max(1, Math.round(total * FPS))
+    const ffmpeg = spawn(
+        'ffmpeg',
+        [
+            '-y', '-loglevel', 'error',
+            '-f', 'image2pipe', '-framerate', String(FPS), '-c:v', 'mjpeg', '-i', '-',
+            '-vf', 'scale=trunc(iw/2)*2:trunc(ih/2)*2',
+            '-c:v', 'libx264', '-preset', 'slow', '-crf', '15', '-pix_fmt', 'yuv420p', '-r', String(FPS),
+            // A keyframe every second: HyperFrames seeks frame by frame.
+            '-g', String(FPS), '-keyint_min', String(FPS),
+            '-movflags', '+faststart', '-an', mp4,
+        ],
+        { stdio: ['pipe', 'inherit', 'inherit'] },
+    )
+    const done = new Promise<boolean>((resolveDone) => {
+        ffmpeg.on('error', () => resolveDone(false))
+        ffmpeg.on('close', (code) => resolveDone(code === 0))
+    })
+    ffmpeg.stdin.on('error', () => {}) // ffmpeg exiting early is reported by `done`
+
+    let index = 0
+    let endOfCurrent = schedule[0].duration
+    let loaded = -1
+    let bytes = Buffer.alloc(0)
+    for (let k = 0; k < count; k++) {
+        const t = k / FPS
+        while (index < schedule.length - 1 && t >= endOfCurrent - 1e-9) {
+            index++
+            endOfCurrent += schedule[index].duration
+        }
+        if (index !== loaded) {
+            bytes = readFileSync(schedule[index].file)
+            loaded = index
+        }
+        if (!ffmpeg.stdin.write(bytes)) {
+            await new Promise((drained) => ffmpeg.stdin.once('drain', drained))
+        }
+    }
+    ffmpeg.stdin.end()
+
+    return done
+}

package/skills/reelson-record/scripts/config.js

@@ -0,0 +1,148 @@
+/**
+ * Per-project settings shared by reelson-record and reelson-compose.
+ *
+ * Each project that uses the kit keeps a `demo.config.json` at its root (copy
+ * demo.config.example.json from the kit). The scripts find it by walking up
+ * from the scenario / demo directory, then from the working directory. Every
+ * field is optional; DEFAULTS below apply to whatever is missing, so a project
+ * without a config still works (neutral brand, English strings, no music).
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { stringsFor } from "./languages.js";
+import { loadSchema, validate } from "./validate.js";
+/** JSON Schema for demo.config.json (editors pick it up through `$schema`). */
+export const CONFIG_SCHEMA_PATH = resolve(dirname(fileURLToPath(import.meta.url)), '../schemas/demo.config.schema.json');
+export const DEFAULTS = {
+    videosDir: 'docs/videos',
+    language: 'en',
+    locale: 'en-US',
+    brand: {
+        name: 'YOUR BRAND',
+        tagline: 'PRODUCT',
+        eyebrow: 'Your Brand',
+        color: '#dc2626',
+        colorSoft: '#f87171',
+        logo: null,
+    },
+    template: 'classic',
+    sections: {},
+    strings: {
+        recapTitle: 'In short',
+        stepsLabel: { one: 'step', other: 'steps' },
+        secondsLabel: { one: 'second', other: 'seconds' },
+    },
+    music: { file: null, lufs: -28, lufsUnderNarration: -34 },
+    voice: {
+        provider: 'openai',
+        instructions: 'Like a colleague showing a feature on a screen share: natural and conversational, a brisk, easy pace with no gaps between words; light and confident. Native pronunciation of the language. Not an announcer, no exaggerated enthusiasm.',
+        lufs: -16,
+    },
+    record: {
+        viewport: { width: 1440, height: 900 },
+        deviceScaleFactor: 2,
+        extraHTTPHeaders: { 'X-Demo-Recording': '1' },
+        hideSelectors: [],
+        personaDomain: 'example.com',
+        cursor: 'layer',
+        capture: 'screencast',
+        mobile: { device: 'Pixel 7' },
+        square: { viewport: { width: 1080, height: 1080 } },
+    },
+};
+/**
+ * Local-only UI that should never be filmed, hidden in every project on top of
+ * `record.hideSelectors`.
+ */
+export const COMMON_DEV_CHROME = [
+    '.phpdebugbar',
+    '.phpdebugbar-openhandler', // Laravel Debugbar
+    'form[action*="filament-developer-logins"]', // Filament developer logins (login page buttons)
+    '[wire\\:snapshot*="menu-logins"]', // … and its "Switch to" topbar menu
+    '.sf-toolbar',
+    '.sf-minitoolbar', // Symfony web debug toolbar
+    '#djDebug', // Django Debug Toolbar
+    '.profiler-results', // rack-mini-profiler
+    'vite-error-overlay', // Vite
+    'nextjs-portal', // Next.js dev indicator
+    '#__next-build-watcher',
+    '[data-nextjs-toast]',
+    '#nuxt-devtools-container', // Nuxt DevTools
+    'astro-dev-toolbar', // Astro dev toolbar
+    '#webpack-dev-server-client-overlay',
+];
+export function loadConfig(...startDirs) {
+    const path = [...startDirs, process.cwd()]
+        .map((dir) => findUp(resolve(dir), 'demo.config.json'))
+        .find((p) => p !== null);
+    if (!path) {
+        return { ...DEFAULTS, root: process.cwd(), path: null };
+    }
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    const problems = validate(raw, loadSchema(CONFIG_SCHEMA_PATH));
+    if (problems.length) {
+        throw new ConfigError(path, problems);
+    }
+    // The language's built-in strings (plurals, recap title) first; demo.config.json `strings` on top.
+    const merged = deepMerge({ ...DEFAULTS, strings: stringsFor(raw.language ?? DEFAULTS.language) }, raw);
+    // Plural forms replace the defaults as a whole: merging would leak "step" into { other: "pași" }.
+    for (const key of ['stepsLabel', 'secondsLabel']) {
+        const own = raw.strings?.[key];
+        if (own !== undefined) {
+            merged.strings[key] = own;
+        }
+    }
+    return { ...merged, root: dirname(path), path };
+}
+export class ConfigError extends Error {
+    file;
+    problems;
+    constructor(file, problems) {
+        super(`${file} is invalid:\n  ${problems.join('\n  ')}`);
+        this.file = file;
+        this.problems = problems;
+    }
+}
+/** "1 step", "4 steps", "20 de pași": the count followed by the right plural form. */
+export function countLabel(count, label, language) {
+    if (typeof label === 'string') {
+        return `${count} ${label}`;
+    }
+    const category = new Intl.PluralRules(language).select(count);
+    return `${count} ${label[category] ?? label.other}`;
+}
+/** Resolves a path from the config against the project root. */
+export function fromRoot(config, path) {
+    return isAbsolute(path) ? path : resolve(config.root, path);
+}
+function findUp(dir, name) {
+    let current = dir;
+    while (true) {
+        const candidate = resolve(current, name);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function deepMerge(base, override) {
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+        return (override === undefined ? base : override);
+    }
+    const out = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (key.startsWith('$')) {
+            continue;
+        }
+        out[key] = deepMerge(base[key], value);
+    }
+    return out;
+}
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}

package/skills/reelson-record/scripts/config.ts

@@ -0,0 +1,264 @@
+/**
+ * Per-project settings shared by reelson-record and reelson-compose.
+ *
+ * Each project that uses the kit keeps a `demo.config.json` at its root (copy
+ * demo.config.example.json from the kit). The scripts find it by walking up
+ * from the scenario / demo directory, then from the working directory. Every
+ * field is optional; DEFAULTS below apply to whatever is missing, so a project
+ * without a config still works (neutral brand, English strings, no music).
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, isAbsolute, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { stringsFor } from './languages.ts'
+import { loadSchema, validate } from './validate.ts'
+
+/** JSON Schema for demo.config.json (editors pick it up through `$schema`). */
+export const CONFIG_SCHEMA_PATH = resolve(
+    dirname(fileURLToPath(import.meta.url)),
+    '../schemas/demo.config.schema.json',
+)
+
+/** A noun that follows a number: one string, or forms per Intl.PluralRules category. */
+export type Label = string | Partial<Record<Intl.LDMLPluralRule, string>> & { other: string }
+
+export interface DemoConfig {
+    /** Where demo folders live, relative to the project root. */
+    videosDir: string
+    /** BCP 47 language of the product UI; drives <html lang> and persona names. */
+    language: string
+    /** Browser locale while recording (Accept-Language, Intl formatting). */
+    locale: string
+    brand: {
+        /** Wordmark on the cover and the closing card, e.g. "ACME". */
+        name: string
+        /** Small spaced line under the wordmark, e.g. "PLATFORM". Empty hides it. */
+        tagline: string
+        /** Label above the recap title, e.g. "Acme". */
+        eyebrow: string
+        /** Primary accent (numbers, lines, click ring). Any CSS color. */
+        color: string
+        /** Lighter accent for gradients. */
+        colorSoft: string
+        /** Logo image (SVG, PNG or WebP) shown instead of the text wordmark; relative to the project root. */
+        logo: string | null
+    }
+    /** Template folder name under reelson-compose/templates/ (or <videosDir>/_templates/). */
+    template: string
+    /** Section per slot (intro, recap, outro) over the template's defaults; "recap": "none" drops the recap. */
+    sections: { intro?: string; recap?: string; outro?: string }
+    /** Every piece of on-card text that is not per-video. */
+    strings: {
+        recapTitle: string
+        /** Chip on the cover: "{steps} {stepsLabel} · {seconds} {secondsLabel}". */
+        stepsLabel: Label
+        secondsLabel: Label
+    }
+    music: {
+        /** Audio file laid under every video, relative to the project root. null = no music. */
+        file: string | null
+        /** Integrated loudness of the bed under silent footage / under narration. */
+        lufs: number
+        lufsUnderNarration: number
+    }
+    /** Voice-over (video.json "voice": true): each callout spoken by a text-to-speech provider. */
+    voice: {
+        /** openai (or a local OpenAI-compatible server), elevenlabs, piper (local), command (local). */
+        provider: 'openai' | 'elevenlabs' | 'piper' | 'command'
+        /** The provider's model (default: its own, e.g. gpt-4o-mini-tts, eleven_multilingual_v2). */
+        model?: string
+        /** The provider's voice (default: its own; Piper: one for the project's language). */
+        voice?: string
+        /** How to speak (tone, pace, accent) — for models that take instructions (gpt-4o-mini-tts). */
+        instructions: string
+        /** Speaking rate, 1 = normal (OpenAI tts-1, ElevenLabs 0.7–1.2, Piper). */
+        speed?: number
+        /** openai: API root of a local OpenAI-compatible server. */
+        baseURL?: string
+        /** command: argv with {text} {out} {voice} {model} {speed} {language}. */
+        command?: string[]
+        /** Extra request fields (openai, elevenlabs) or --flags (piper). */
+        options?: Record<string, unknown>
+        /** Integrated loudness of the voice track. */
+        lufs: number
+    }
+    record: {
+        viewport: { width: number; height: number }
+        /** Capture pixel ratio; 2 keeps UI text sharp in the 1080p frame and under zooms. */
+        deviceScaleFactor: number
+        /** Sent with every request so the app can switch off local-only prefills on camera. */
+        extraHTTPHeaders: Record<string, string>
+        /** CSS selectors hidden in every recorded page (dev toolbars, env badges). */
+        hideSelectors: string[]
+        /** Email domain for demo.persona(). Use one that resolves if a gateway validates emails. */
+        personaDomain: string
+        /**
+         * 'layer': the cursor is logged, not filmed, and the video draws it (constant size under
+         * zooms, restyled without re-recording). 'recorded': drawn into the page and filmed.
+         */
+        cursor: 'layer' | 'recorded'
+        /**
+         * 'screencast': every frame Chrome paints (up to 60 fps), assembled into a smooth
+         * 30 fps recording. 'playwright': Playwright's own 25 fps video (the pre-0.5 way).
+         */
+        capture: 'screencast' | 'playwright'
+        /** `reelson record --mobile`: the Playwright device the phone take uses. */
+        mobile: { device: string }
+        /** `reelson record --square`: the browser the square take uses (CSS px). */
+        square: { viewport: { width: number; height: number } }
+    }
+}
+
+export const DEFAULTS: DemoConfig = {
+    videosDir: 'docs/videos',
+    language: 'en',
+    locale: 'en-US',
+    brand: {
+        name: 'YOUR BRAND',
+        tagline: 'PRODUCT',
+        eyebrow: 'Your Brand',
+        color: '#dc2626',
+        colorSoft: '#f87171',
+        logo: null,
+    },
+    template: 'classic',
+    sections: {},
+    strings: {
+        recapTitle: 'In short',
+        stepsLabel: { one: 'step', other: 'steps' },
+        secondsLabel: { one: 'second', other: 'seconds' },
+    },
+    music: { file: null, lufs: -28, lufsUnderNarration: -34 },
+    voice: {
+        provider: 'openai',
+        instructions:
+            'Like a colleague showing a feature on a screen share: natural and conversational, a brisk, easy pace with no gaps between words; light and confident. Native pronunciation of the language. Not an announcer, no exaggerated enthusiasm.',
+        lufs: -16,
+    },
+    record: {
+        viewport: { width: 1440, height: 900 },
+        deviceScaleFactor: 2,
+        extraHTTPHeaders: { 'X-Demo-Recording': '1' },
+        hideSelectors: [],
+        personaDomain: 'example.com',
+        cursor: 'layer',
+        capture: 'screencast',
+        mobile: { device: 'Pixel 7' },
+        square: { viewport: { width: 1080, height: 1080 } },
+    },
+}
+
+/**
+ * Local-only UI that should never be filmed, hidden in every project on top of
+ * `record.hideSelectors`.
+ */
+export const COMMON_DEV_CHROME = [
+    '.phpdebugbar',
+    '.phpdebugbar-openhandler', // Laravel Debugbar
+    'form[action*="filament-developer-logins"]', // Filament developer logins (login page buttons)
+    '[wire\\:snapshot*="menu-logins"]', // … and its "Switch to" topbar menu
+    '.sf-toolbar',
+    '.sf-minitoolbar', // Symfony web debug toolbar
+    '#djDebug', // Django Debug Toolbar
+    '.profiler-results', // rack-mini-profiler
+    'vite-error-overlay', // Vite
+    'nextjs-portal', // Next.js dev indicator
+    '#__next-build-watcher',
+    '[data-nextjs-toast]',
+    '#nuxt-devtools-container', // Nuxt DevTools
+    'astro-dev-toolbar', // Astro dev toolbar
+    '#webpack-dev-server-client-overlay',
+]
+
+export interface LoadedConfig extends DemoConfig {
+    /** Directory holding demo.config.json (or the working directory without one). */
+    root: string
+    /** Path of the config file, when one was found. */
+    path: string | null
+}
+
+export function loadConfig(...startDirs: string[]): LoadedConfig {
+    const path = [...startDirs, process.cwd()]
+        .map((dir) => findUp(resolve(dir), 'demo.config.json'))
+        .find((p): p is string => p !== null)
+    if (!path) {
+        return { ...DEFAULTS, root: process.cwd(), path: null }
+    }
+    const raw = JSON.parse(readFileSync(path, 'utf8')) as Partial<DemoConfig>
+    const problems = validate(raw, loadSchema(CONFIG_SCHEMA_PATH))
+    if (problems.length) {
+        throw new ConfigError(path, problems)
+    }
+
+    // The language's built-in strings (plurals, recap title) first; demo.config.json `strings` on top.
+    const merged = deepMerge({ ...DEFAULTS, strings: stringsFor(raw.language ?? DEFAULTS.language) }, raw)
+    // Plural forms replace the defaults as a whole: merging would leak "step" into { other: "pași" }.
+    for (const key of ['stepsLabel', 'secondsLabel'] as const) {
+        const own = raw.strings?.[key]
+        if (own !== undefined) {
+            merged.strings[key] = own
+        }
+    }
+
+    return { ...merged, root: dirname(path), path }
+}
+
+export class ConfigError extends Error {
+    file: string
+    problems: string[]
+
+    constructor(file: string, problems: string[]) {
+        super(`${file} is invalid:\n  ${problems.join('\n  ')}`)
+        this.file = file
+        this.problems = problems
+    }
+}
+
+/** "1 step", "4 steps", "20 de pași": the count followed by the right plural form. */
+export function countLabel(count: number, label: Label, language: string): string {
+    if (typeof label === 'string') {
+        return `${count} ${label}`
+    }
+    const category = new Intl.PluralRules(language).select(count)
+
+    return `${count} ${label[category] ?? label.other}`
+}
+
+/** Resolves a path from the config against the project root. */
+export function fromRoot(config: LoadedConfig, path: string): string {
+    return isAbsolute(path) ? path : resolve(config.root, path)
+}
+
+function findUp(dir: string, name: string): string | null {
+    let current = dir
+    while (true) {
+        const candidate = resolve(current, name)
+        if (existsSync(candidate)) {
+            return candidate
+        }
+        const parent = dirname(current)
+        if (parent === current) {
+            return null
+        }
+        current = parent
+    }
+}
+
+function deepMerge<T>(base: T, override: unknown): T {
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+        return (override === undefined ? base : override) as T
+    }
+    const out: Record<string, unknown> = { ...base }
+    for (const [key, value] of Object.entries(override)) {
+        if (key.startsWith('$')) {
+            continue
+        }
+        out[key] = deepMerge((base as Record<string, unknown>)[key], value)
+    }
+
+    return out as T
+}
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+    return typeof v === 'object' && v !== null && !Array.isArray(v)
+}