disaster-broadcast-studio 0.1.1 → 0.2.0

package/dist/preview/http.js

@@ -0,0 +1,78 @@
+import { createServer } from 'node:http';
+import { createReadStream } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+const contentTypes = {
+    '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.mjs': 'text/javascript',
+    '.css': 'text/css', '.woff': 'font/woff', '.woff2': 'font/woff2',
+    '.wav': 'audio/wav', '.mp3': 'audio/mpeg', '.m4a': 'audio/mp4', '.aac': 'audio/aac',
+    '.ogg': 'audio/ogg', '.flac': 'audio/flac', '.mp4': 'video/mp4',
+};
+async function serveFile(request, response, root, relative) {
+    const file = path.resolve(root, relative);
+    if (!file.startsWith(`${path.resolve(root)}${path.sep}`)) {
+        response.writeHead(404).end();
+        return;
+    }
+    let info;
+    try {
+        info = await stat(file);
+    }
+    catch {
+        response.writeHead(404).end();
+        return;
+    }
+    if (!info.isFile()) {
+        response.writeHead(404).end();
+        return;
+    }
+    response.setHeader('Content-Type', contentTypes[path.extname(file).toLowerCase()] ?? 'application/octet-stream');
+    response.setHeader('Accept-Ranges', 'bytes');
+    let start = 0, end = info.size - 1;
+    if (request.headers.range) {
+        const match = /^bytes=(\d*)-(\d*)$/.exec(request.headers.range);
+        if (match && (match[1] || match[2])) {
+            start = match[1] ? Number(match[1]) : Math.max(0, info.size - Number(match[2]));
+            end = match[1] && match[2] ? Math.min(Number(match[2]), end) : end;
+        }
+        if (!match || (!match[1] && !match[2]) || start > end || start >= info.size) {
+            response.writeHead(416, { 'Content-Range': `bytes */${info.size}` }).end();
+            return;
+        }
+        response.statusCode = 206;
+        response.setHeader('Content-Range', `bytes ${start}-${end}/${info.size}`);
+    }
+    response.setHeader('Content-Length', Math.max(0, end - start + 1));
+    if (request.method === 'HEAD' || !info.size) {
+        response.end();
+        return;
+    }
+    const stream = createReadStream(file, { start, end });
+    stream.on('error', () => response.destroy());
+    response.on('close', () => stream.destroy());
+    stream.pipe(response);
+}
+export function createPreviewServer(project, publicDir, bundleDir) {
+    return createServer((request, response) => {
+        response.setHeader('Cache-Control', 'no-store');
+        response.setHeader('X-Content-Type-Options', 'nosniff');
+        void (async () => {
+            if (request.method !== 'GET' && request.method !== 'HEAD') {
+                response.writeHead(405, { Allow: 'GET, HEAD' }).end();
+                return;
+            }
+            const pathname = decodeURIComponent(new URL(request.url ?? '/', 'http://localhost').pathname);
+            if (pathname === '/api/status' || pathname === '/api/scenario') {
+                const body = JSON.stringify(pathname === '/api/status' ? project.status() : project.current());
+                response.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+                response.end(request.method === 'HEAD' ? undefined : body);
+                return;
+            }
+            if (pathname.startsWith('/public/'))
+                await serveFile(request, response, publicDir, pathname.slice('/public/'.length));
+            else
+                await serveFile(request, response, bundleDir, pathname === '/' ? 'index.html' : pathname.slice(1));
+        })().catch(() => { if (!response.headersSent)
+            response.writeHead(400); response.end(); });
+    });
+}

package/dist/preview/page.d.ts

@@ -0,0 +1 @@
+export declare const previewPage = "<!doctype html>\n<html lang=\"ko\">\n<head>\n  <meta charset=\"UTF-8\">\n  <meta name=\"viewport\" content=\"width=device-width,initial-scale=1\">\n  <title>\uC7AC\uB09C\uBC29\uC1A1\uC2E4 \u00B7 \uBBF8\uB9AC\uBCF4\uAE30</title>\n  <style>\n    :root { color-scheme: dark; font-family: system-ui, sans-serif; background: #101417; color: #dce1e5; }\n    * { box-sizing: border-box; }\n    body { margin: 0; }\n    .preview { max-width: 1500px; margin: auto; padding: 24px; }\n    .preview > header, .tools { display: flex; align-items: center; flex-wrap: wrap; gap: 14px; }\n    .preview > header { justify-content: space-between; margin-bottom: 18px; }\n    .preview > header h1 { font-size: 22px; margin: 0; }\n    .preview > p { color: #aab5bd; line-height: 1.6; }\n    .player { background: #000; border: 1px solid #3c464e; }\n    .tools { padding: 16px 0; }\n    .tools button, .tools input, .tools select { font: inherit; padding: 7px 10px; background: #202a31; color: #e4e9ed; border: 1px solid #53616b; border-radius: 4px; }\n    .tools button { cursor: pointer; }\n    .tools input { width: 110px; }\n    .tools label { display: flex; align-items: center; gap: 8px; }\n    .tools output { font-variant-numeric: tabular-nums; }\n    .status { font-size: 14px; color: #aab5bd; }\n    .preview .error { color: #ffd0c8; background: #3c2423; border: 1px solid #8f5952; padding: 14px; white-space: pre-wrap; overflow-wrap: anywhere; }\n    .preview .warnings { color: #e4ce9e; white-space: pre-wrap; }\n    @media (max-width: 700px) { .preview { padding: 12px; } }\n  </style>\n</head>\n<body><div id=\"root\"></div><script>window.remotion_staticBase = '/public';</script><script src=\"/bundle.js\"></script></body>\n</html>";

package/dist/preview/page.js

@@ -0,0 +1,30 @@
+export const previewPage = `<!doctype html>
+<html lang="ko">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <title>재난방송실 · 미리보기</title>
+  <style>
+    :root { color-scheme: dark; font-family: system-ui, sans-serif; background: #101417; color: #dce1e5; }
+    * { box-sizing: border-box; }
+    body { margin: 0; }
+    .preview { max-width: 1500px; margin: auto; padding: 24px; }
+    .preview > header, .tools { display: flex; align-items: center; flex-wrap: wrap; gap: 14px; }
+    .preview > header { justify-content: space-between; margin-bottom: 18px; }
+    .preview > header h1 { font-size: 22px; margin: 0; }
+    .preview > p { color: #aab5bd; line-height: 1.6; }
+    .player { background: #000; border: 1px solid #3c464e; }
+    .tools { padding: 16px 0; }
+    .tools button, .tools input, .tools select { font: inherit; padding: 7px 10px; background: #202a31; color: #e4e9ed; border: 1px solid #53616b; border-radius: 4px; }
+    .tools button { cursor: pointer; }
+    .tools input { width: 110px; }
+    .tools label { display: flex; align-items: center; gap: 8px; }
+    .tools output { font-variant-numeric: tabular-nums; }
+    .status { font-size: 14px; color: #aab5bd; }
+    .preview .error { color: #ffd0c8; background: #3c2423; border: 1px solid #8f5952; padding: 14px; white-space: pre-wrap; overflow-wrap: anywhere; }
+    .preview .warnings { color: #e4ce9e; white-space: pre-wrap; }
+    @media (max-width: 700px) { .preview { padding: 12px; } }
+  </style>
+</head>
+<body><div id="root"></div><script>window.remotion_staticBase = '/public';</script><script src="/bundle.js"></script></body>
+</html>`;

package/dist/preview/project.d.ts

@@ -0,0 +1,22 @@
+import type { BroadcastProps } from '../video/Broadcast.js';
+export type PreviewStatus = {
+    revision: number;
+    warnings: string[];
+    error: string | null;
+};
+export type PreviewSnapshot = PreviewStatus & {
+    props: BroadcastProps;
+};
+export declare class PreviewProject {
+    private file;
+    private publicDir;
+    private signature;
+    private pending;
+    private snapshot;
+    private error;
+    constructor(file: string, publicDir: string);
+    status(): PreviewStatus;
+    current(): PreviewSnapshot;
+    refresh(): Promise<void>;
+    private update;
+}

package/dist/preview/project.js

@@ -0,0 +1,81 @@
+import { createHash } from 'node:crypto';
+import { readFile, rm, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { parseDocument } from 'yaml';
+import { loadScenario } from '../load.js';
+import { prepareBroadcast } from '../video/prepare.js';
+// Read the current document's paths even when validation fails, so creating a
+// missing asset or repairing a custom map also recovers the preview.
+async function fingerprint(file) {
+    const source = await readFile(file, 'utf8');
+    const files = new Set();
+    try {
+        const document = parseDocument(source).toJS();
+        if (typeof document?.map?.regions === 'string')
+            files.add(document.map.regions);
+        for (const asset of Object.values(document?.assets ?? {}))
+            if (typeof asset?.path === 'string')
+                files.add(asset.path);
+    }
+    catch { /* Validation reports malformed documents. */ }
+    const stamps = await Promise.all([...files].sort().map(async (relative) => {
+        try {
+            const info = await stat(path.resolve(path.dirname(file), relative), { bigint: true });
+            return `${relative}:${info.mtimeNs}:${info.ctimeNs}:${info.size}:${info.ino}`;
+        }
+        catch {
+            return `${relative}:missing`;
+        }
+    }));
+    return createHash('sha256').update(source).update(JSON.stringify(stamps)).digest('hex');
+}
+export class PreviewProject {
+    file;
+    publicDir;
+    signature = '';
+    pending;
+    snapshot;
+    error = null;
+    constructor(file, publicDir) {
+        this.file = file;
+        this.publicDir = publicDir;
+    }
+    status() {
+        return { revision: this.snapshot?.revision ?? 0, warnings: this.snapshot?.warnings ?? [], error: this.error };
+    }
+    current() {
+        if (!this.snapshot)
+            throw Error(this.error ?? 'Preview is not ready');
+        return { ...this.snapshot, error: this.error };
+    }
+    refresh() {
+        if (this.pending)
+            return this.pending;
+        this.pending = this.update().finally(() => { this.pending = undefined; });
+        return this.pending;
+    }
+    async update() {
+        let revision = 0;
+        let fingerprinted = false;
+        try {
+            const signature = await fingerprint(this.file);
+            fingerprinted = true;
+            if (signature === this.signature)
+                return;
+            this.signature = signature;
+            const loaded = await loadScenario(this.file);
+            revision = (this.snapshot?.revision ?? 0) + 1;
+            const props = await prepareBroadcast(loaded, this.publicDir, `audio/${revision}`);
+            this.snapshot = { props, revision, warnings: loaded.warnings, error: null };
+            this.error = null;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+            // Retry preparation failures even if the input has not changed.
+            if (revision || !fingerprinted)
+                this.signature = '';
+        }
+        if (revision && this.error)
+            await rm(path.join(this.publicDir, 'audio', String(revision)), { recursive: true, force: true });
+    }
+}

package/dist/preview/server.d.ts

@@ -0,0 +1,6 @@
+export declare function startPreview(file: string, options?: {
+    port?: number;
+}): Promise<{
+    url: string;
+    close: () => Promise<void>;
+}>;

package/dist/preview/server.js

@@ -0,0 +1,57 @@
+import { bundle } from '@remotion/bundler';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { packageRoot } from '../assets.js';
+import { prepareStaticAssets } from '../video/prepare.js';
+import { PreviewProject } from './project.js';
+import { previewPage } from './page.js';
+import { createPreviewServer } from './http.js';
+export async function startPreview(file, options = {}) {
+    const port = options.port ?? 3000;
+    if (!Number.isInteger(port) || port < 0 || port > 65535)
+        throw Error('--port: expected 0..65535');
+    const absolute = path.resolve(file);
+    const temp = await mkdtemp(path.join(tmpdir(), 'dbs-preview-'));
+    const publicDir = path.join(temp, 'public');
+    const bundleDir = path.join(temp, 'bundle');
+    const project = new PreviewProject(absolute, publicDir);
+    const server = createPreviewServer(project, publicDir, bundleDir);
+    let timer;
+    let closing;
+    const close = () => closing ??= (async () => {
+        clearInterval(timer);
+        if (server.listening) {
+            const stopped = new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
+            server.closeAllConnections();
+            await stopped;
+        }
+        await project.refresh(); // Wait for any in-flight preparation before cleanup.
+        await rm(temp, { recursive: true, force: true });
+    })();
+    try {
+        await project.refresh();
+        project.current(); // Invalid initial input fails before opening a port.
+        await prepareStaticAssets(publicDir);
+        const entryPoint = path.join(packageRoot, 'dist/preview/browser.js');
+        await bundle({
+            entryPoint, publicDir, outDir: bundleDir, rootDir: packageRoot,
+            ignoreRegisterRootWarning: true,
+            webpackOverride: config => ({
+                ...config, entry: entryPoint,
+            }),
+        });
+        await writeFile(path.join(bundleDir, 'index.html'), previewPage);
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(port, '127.0.0.1', () => { server.off('error', reject); resolve(); });
+        });
+        timer = setInterval(() => { void project.refresh(); }, 750);
+        const address = server.address();
+        return { url: `http://127.0.0.1:${address.port}`, close };
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+}

package/dist/render.js

@@ -1,13 +1,11 @@
 import { bundle } from '@remotion/bundler';
 import { renderStill, renderMedia, selectComposition } from '@remotion/renderer';
-import { mkdir, copyFile, readFile, writeFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
+import { writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { withOutputFiles } from './output.js';
-import { fonts } from './video/fonts.js';
+import { prepareStaticAssets, prepareBroadcast } from './video/prepare.js';
 import { readBundledJson, packageRoot } from './assets.js';
 import { makeCredits } from './credits.js';
-const require = createRequire(import.meta.url);
 export async function render(loaded, options) {
     const out = path.resolve(options.out), last = loaded.timeline.durationInFrames - 1;
     const still = options.frame !== undefined, from = options.from ?? 0, to = options.to ?? last;
@@ -22,42 +20,8 @@ export async function render(loaded, options) {
         throw Error('--concurrency: expected positive integer');
     await withOutputFiles(out, { overwrite: options.overwrite, sidecars: ['.json', '.credits.txt'] }, async (pending, temp) => {
         const publicDir = path.join(temp, 'public');
-        await mkdir(path.join(publicDir, 'fonts', 'files'), { recursive: true });
-        for (const name of ['maplibre-gl-worker.mjs', 'maplibre-gl-shared.mjs'])
-            await copyFile(require.resolve(`maplibre-gl/dist/${name}`), path.join(publicDir, name));
-        for (const font of fonts) {
-            const fontRoot = path.dirname(require.resolve(`${font.package}/package.json`));
-            for (const weight of font.weights) {
-                const css = await readFile(path.join(fontRoot, `${weight}.css`), 'utf8');
-                await writeFile(path.join(publicDir, 'fonts', `${font.id}-${weight}.css`), css);
-                for (const match of css.matchAll(/url\(([^)]+)\)/g)) {
-                    const relative = match[1].replace(/['"]/g, '');
-                    await copyFile(path.join(fontRoot, relative), path.join(publicDir, 'fonts', relative));
-                }
-            }
-        }
-        const audio = {};
-        for (const [id, file] of Object.entries(loaded.assetPaths)) {
-            const name = `audio/${id}${path.extname(file)}`;
-            await mkdir(path.join(publicDir, 'audio'), { recursive: true });
-            await copyFile(file, path.join(publicDir, name));
-            audio[id] = name;
-        }
-        const countries = await readBundledJson('countries.geojson.gz');
-        const defaultRegions = !loaded.timeline.scenario.map.regions;
-        // The full SGIS polygons supply the Korean coastline and administrative fills.
-        if (defaultRegions)
-            countries.features = countries.features.filter((f) => f.properties?.code !== 'KOR');
-        const provinces = defaultRegions
-            ? await readBundledJson('provinces.geojson.gz')
-            : { type: 'FeatureCollection', features: [] };
-        const inputProps = {
-            timeline: loaded.timeline,
-            regions: loaded.regions,
-            countries,
-            provinces,
-            audio,
-        };
+        await prepareStaticAssets(publicDir);
+        const inputProps = await prepareBroadcast(loaded, publicDir);
         const serveUrl = await bundle({
             entryPoint: path.join(packageRoot, 'dist/video/index.js'),
             publicDir,

package/dist/scenario.d.ts

@@ -57,6 +57,11 @@ export declare const scenarioSchema: z.ZodObject<{
         at: z.ZodNumber;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"news">;
+        sound: z.ZodDefault<z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodLiteral<"default">, z.ZodObject<{
+            asset: z.ZodString;
+            duration: z.ZodNumber;
+            volume: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>]>>>;
         source: z.ZodString;
         headline: z.ZodString;
         publishedAt: z.ZodOptional<z.ZodString>;
@@ -67,6 +72,11 @@ export declare const scenarioSchema: z.ZodObject<{
         at: z.ZodNumber;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"status">;
+        sound: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodLiteral<"default">, z.ZodObject<{
+            asset: z.ZodString;
+            duration: z.ZodNumber;
+            volume: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>]>>;
         items: z.ZodArray<z.ZodObject<{
             text: z.ZodString;
             color: z.ZodString;
@@ -78,6 +88,11 @@ export declare const scenarioSchema: z.ZodObject<{
         at: z.ZodNumber;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"bulletin">;
+        sound: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodLiteral<"default">, z.ZodObject<{
+            asset: z.ZodString;
+            duration: z.ZodNumber;
+            volume: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>]>>;
         source: z.ZodString;
         heading: z.ZodString;
         text: z.ZodString;

package/dist/scenario.js

@@ -18,6 +18,19 @@ const span = {
     duration: z.number().positive(),
     carry: z.boolean().default(false),
 };
+const notificationSound = z
+    .union([
+    z.literal(false),
+    z.literal('default'),
+    z
+        .object({
+        asset: id,
+        duration: z.number().positive(),
+        volume: z.number().min(0).max(2).default(0.8),
+    })
+        .strict(),
+])
+    .default('default');
 const alert = z
     .object({
     ...timed,
@@ -37,19 +50,7 @@ const alert = z
             .strict(),
     ])
         .default({ duration: 2.4, color: '#d6e2ec' }),
-    sound: z
-        .union([
-        z.literal(false),
-        z.literal('default'),
-        z
-            .object({
-            asset: id,
-            duration: z.number().positive(),
-            volume: z.number().min(0).max(2).default(0.8),
-        })
-            .strict(),
-    ])
-        .default('default'),
+    sound: notificationSound,
     corrects: id.optional(),
     occurredAt: timestamp.optional(),
     publishedAt: timestamp.optional(),
@@ -60,6 +61,7 @@ const news = z
     .object({
     ...span,
     type: z.literal('news'),
+    sound: notificationSound.default(false),
     source: id,
     headline: z.string().min(1).max(160),
     publishedAt: timestamp.optional(),
@@ -69,6 +71,7 @@ const status = z
     .object({
     ...span,
     type: z.literal('status'),
+    sound: notificationSound,
     items: z.array(z.object({ text: z.string().min(1).max(80), color }).strict()),
 })
     .strict();
@@ -76,6 +79,7 @@ const bulletin = z
     .object({
     ...span,
     type: z.literal('bulletin'),
+    sound: notificationSound,
     source: id,
     heading: z.string().min(1).max(80),
     text: z.string().min(1).max(4000),
@@ -322,9 +326,9 @@ export function compile(scenario, regionIds) {
             for (const r of e.regions)
                 if (!regionIds.has(r))
                     errors.push(`${path}.regions: unknown region ${r}`);
+        if ('sound' in e && typeof e.sound === 'object' && !Object.hasOwn(scenario.assets, e.sound.asset))
+            errors.push(`${path}.sound.asset: unknown asset ${e.sound.asset}`);
         if (e.type === 'alert') {
-            if (typeof e.sound === 'object' && !Object.hasOwn(scenario.assets, e.sound.asset))
-                errors.push(`${path}.sound.asset: unknown asset ${e.sound.asset}`);
             if (!Object.hasOwn(scenario.agencies, e.sender))
                 errors.push(`${path}.sender: unknown agency ${e.sender}`);
             if (e.corrects) {

package/dist/timeline.d.ts

@@ -1,6 +1,7 @@
 import { type Timeline, type Camera, type CompiledEvent } from './scenario.js';
 export declare const active: (e: CompiledEvent, frame: number) => boolean;
 export declare const mix: (a: number, b: number, t: number) => number;
+export declare function notificationPulse(frame: number, start: number, end: number): number;
 export declare function cameraAt(t: Timeline, frame: number): Camera;
 export declare function receiptHighlights(t: Timeline, frame: number): Extract<CompiledEvent, {
     type: 'region';
@@ -8,11 +9,6 @@ export declare function receiptHighlights(t: Timeline, frame: number): Extract<C
 export declare function regionOpacity(e: Extract<CompiledEvent, {
     type: 'region';
 }>, frame: number, fill?: boolean): number;
-export declare function statusEntry(frame: number, start: number, duration?: number): {
-    opacity: number;
-    offset: number;
-    glow: number;
-};
 export declare function shutdownAt(events: CompiledEvent[], frame: number): {
     y: number;
     x: number;
@@ -37,6 +33,11 @@ export declare function stateAt(t: Timeline, frame: number): {
     visible: CompiledEvent[];
     news: ({
         type: "news";
+        sound: false | "default" | {
+            asset: string;
+            duration: number;
+            volume: number;
+        };
         source: string;
         headline: string;
         duration: number;

package/dist/timeline.js

@@ -1,6 +1,12 @@
 import { FPS } from './scenario.js';
 export const active = (e, frame) => e.start <= frame && frame < e.end;
 export const mix = (a, b, t) => a + (b - a) * t;
+// Three smooth pulses, bounded by the authored frame interval.
+export function notificationPulse(frame, start, end) {
+    if (frame < start || frame >= end)
+        return 0;
+    return Math.sin(((frame - start) / (end - start)) * Math.PI * 3) ** 2;
+}
 export function cameraAt(t, frame) {
     let cam = { ...t.scenario.map.camera };
     for (const e of t.events) {
@@ -21,7 +27,8 @@ export function receiptHighlights(t, frame) {
     return t.events.flatMap((e) => {
         if (e.type !== 'alert' || !e.mapHighlight || !e.regions.length)
             return [];
-        const end = Math.min(t.durationInFrames, e.start + Math.round(e.mapHighlight.duration * FPS));
+        const highlightEnd = e.start + Math.round(e.mapHighlight.duration * FPS);
+        const end = Math.min(t.durationInFrames, highlightEnd);
         if (frame < e.start || frame >= end)
             return [];
         return [
@@ -37,13 +44,13 @@ export function receiptHighlights(t, frame) {
                 order: e.order,
                 regions: e.regions,
                 color: e.mapHighlight.color,
-                fillOpacity: 0.28,
+                fillOpacity: 0.28 * notificationPulse(frame, e.start, highlightEnd),
                 strokeColor: e.mapHighlight.color,
                 strokeOpacity: 0,
                 strokeWidth: 0,
                 pulse: false,
-                fadeIn: Math.min(0.2, e.mapHighlight.duration * 0.2),
-                fadeOut: Math.min(0.7, e.mapHighlight.duration * 0.4),
+                fadeIn: Math.min(0.1, e.mapHighlight.duration / 12),
+                fadeOut: Math.min(0.1, e.mapHighlight.duration / 12),
             },
         ];
     });
@@ -52,10 +59,6 @@ export function regionOpacity(e, frame, fill = true) {
     const fade = envelope(frame, e.start, e.end, e.fadeIn, e.fadeOut);
     return (fade * (fill && e.pulse ? 0.88 + 0.12 * Math.cos(((frame - e.start) / FPS) * Math.PI * 0.9) : 1));
 }
-export function statusEntry(frame, start, duration = 0.55) {
-    const p = Math.max(0, Math.min(1, (frame - start) / (duration * FPS)));
-    return { opacity: 0.4 + 0.6 * p, offset: (1 - p) * -5, glow: (1 - p) * 0.22 };
-}
 export function shutdownAt(events, frame) {
     const e = events.find((e) => e.type === 'screen' && e.effect === 'shutdown' && e.intensity > 0 && active(e, frame));
     if (!e)