disaster-broadcast-studio 0.1.1 → 0.3.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

@@ -48,15 +48,18 @@ export declare const scenarioSchema: z.ZodObject<{
             duration: z.ZodNumber;
             volume: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strict>]>>;
-        corrects: z.ZodOptional<z.ZodString>;
         occurredAt: z.ZodOptional<z.ZodString>;
         publishedAt: z.ZodOptional<z.ZodString>;
-        pageSeconds: z.ZodDefault<z.ZodNumber>;
         id: z.ZodString;
         cut: z.ZodString;
         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 +70,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,16 +86,37 @@ 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;
         color: z.ZodDefault<z.ZodString>;
-        pageSeconds: z.ZodDefault<z.ZodNumber>;
         duration: z.ZodNumber;
         carry: z.ZodDefault<z.ZodBoolean>;
         id: z.ZodString;
         cut: z.ZodString;
         at: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"chat">;
+        title: z.ZodDefault<z.ZodString>;
+        duration: z.ZodNumber;
+        carry: z.ZodDefault<z.ZodBoolean>;
+        id: z.ZodString;
+        cut: z.ZodString;
+        at: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"chat-message">;
+        chat: z.ZodString;
+        author: z.ZodString;
+        text: z.ZodString;
+        color: z.ZodDefault<z.ZodString>;
+        id: z.ZodString;
+        cut: z.ZodString;
+        at: z.ZodNumber;
     }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"zone">;
         points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
@@ -252,5 +281,4 @@ export type Timeline = {
 export declare const FPS = 60;
 export declare const frames: (seconds: number) => number;
 export declare const alertText: (sender: string, text: string) => string;
-export declare const pages: (text: string) => string[];
 export declare function compile(scenario: Scenario, regionIds: Set<string>): Timeline;

package/dist/scenario.js

@@ -4,6 +4,8 @@ const seconds = z.number().finite().nonnegative();
 const color = z.string().regex(/^#[0-9a-fA-F]{6}$/);
 const position = z.tuple([z.number().min(-180).max(180), z.number().min(-85).max(85)]);
 const timestamp = z.string().datetime({ offset: true });
+const fitsText = (text, columns, lines) => text.split(/\r\n|\r|\n/).reduce((count, line) => count + Math.max(1, Math.ceil(Array.from(line.replace(/\t/g, '        ')).length / columns)), 0) <= lines;
+const shortText = (characters, columns, lines) => z.string().trim().min(1).max(characters).refine((text) => fitsText(text, columns, lines), 'Shorten the text or remove line breaks so the full message fits at once');
 const camera = z
     .object({
     center: position,
@@ -18,12 +20,25 @@ 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,
     type: z.literal('alert'),
     sender: id,
-    text: z.string().min(1).max(4000),
+    text: shortText(120, 16, 8),
     level: z.enum(['안전안내', '긴급재난', '위급재난']).default('안전안내'),
     regions: z.array(z.string()).default([]),
     mapHighlight: z
@@ -37,31 +52,18 @@ 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'),
-    corrects: id.optional(),
+    sound: notificationSound,
     occurredAt: timestamp.optional(),
     publishedAt: timestamp.optional(),
-    pageSeconds: z.number().min(3).default(8),
 })
     .strict();
 const news = z
     .object({
     ...span,
     type: z.literal('news'),
+    sound: notificationSound.default(false),
     source: id,
-    headline: z.string().min(1).max(160),
+    headline: shortText(64, 32, 2),
     publishedAt: timestamp.optional(),
 })
     .strict();
@@ -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,11 +79,28 @@ 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),
+    heading: shortText(40, 26, 2),
+    text: shortText(180, 30, 6),
     color: color.default('#b7c1c8'),
-    pageSeconds: z.number().min(3).default(12),
+})
+    .strict();
+const chat = z
+    .object({
+    ...span,
+    type: z.literal('chat'),
+    title: z.string().trim().min(1).max(30).regex(/^[^\r\n]+$/, 'Use a single line').default('실시간 채팅'),
+})
+    .strict();
+const chatMessage = z
+    .object({
+    ...timed,
+    type: z.literal('chat-message'),
+    chat: id,
+    author: z.string().trim().min(1).max(20).regex(/^[^\r\n]+$/, 'Use a single line'),
+    text: z.string().trim().min(1).max(80).regex(/^[^\r\n]+$/, 'Use a single line'),
+    color: color.default('#9fb8cb'),
 })
     .strict();
 const zone = z
@@ -231,6 +251,8 @@ export const scenarioSchema = z
         news,
         status,
         bulletin,
+        chat,
+        chatMessage,
         zone,
         line,
         highlight,
@@ -248,24 +270,6 @@ export const scenarioSchema = z
 export const FPS = 60;
 export const frames = (seconds) => Math.round(seconds * FPS);
 export const alertText = (sender, text) => text.includes(`[${sender}]`) ? text : `[${sender}] ${text}`;
-export const pages = (text) => {
-    const result = [];
-    let remaining = Array.from(new Intl.Segmenter('ko', { granularity: 'grapheme' }).segment(text), (x) => x.segment);
-    while (remaining.length > 100) {
-        const part = remaining.slice(0, 100);
-        let boundary = 99;
-        for (let i = 99; i >= 60; i--)
-            if (/[\s]/.test(part[i])) {
-                boundary = i;
-                break;
-            }
-        result.push(remaining.slice(0, boundary + 1).join(''));
-        remaining = remaining.slice(boundary + 1);
-    }
-    if (remaining.length)
-        result.push(remaining.join(''));
-    return result;
-};
 export function compile(scenario, regionIds) {
     const errors = [];
     try {
@@ -322,22 +326,23 @@ 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) {
-                const prev = scenario.events.find((x) => x.id === e.corrects);
-                if (!prev || prev.type !== 'alert')
-                    errors.push(`${path}.corrects: unknown alert ${e.corrects}`);
-            }
+            else if (!fitsText(alertText(scenario.agencies[e.sender], e.text), 16, 8))
+                errors.push(`${path}.text: shorten the message including its sender so the full text fits at once`);
         }
         if (e.type === 'zone' &&
             (e.points[0][0] !== e.points.at(-1)[0] || e.points[0][1] !== e.points.at(-1)[1]))
             errors.push(`${path}.points: polygon ring must be closed`);
         if ((e.type === 'news' || e.type === 'bulletin') && !Object.hasOwn(scenario.agencies, e.source))
             errors.push(`${path}.source: unknown agency ${e.source}`);
+        else if (e.type === 'news' && !fitsText(scenario.agencies[e.source], 10, 2))
+            errors.push(`${path}.source: shorten the display name so the full source fits beside the headline`);
+        else if (e.type === 'bulletin' && !fitsText(scenario.agencies[e.source], 48, 2))
+            errors.push(`${path}.source: shorten the display name so the full source fits above the notice`);
         if (e.type === 'audio') {
             if (!Object.hasOwn(scenario.assets, e.asset))
                 errors.push(`${path}.asset: unknown asset ${e.asset}`);
@@ -347,10 +352,14 @@ export function compile(scenario, regionIds) {
         return [{ ...e, start, end, order: i }];
     });
     for (const e of events) {
-        if (e.type === 'alert' && e.corrects) {
-            const prior = events.find((x) => x.id === e.corrects);
-            if (prior && prior.start >= e.start)
-                errors.push(`${e.id}.corrects: correction must follow original alert`);
+        if (e.type === 'chat-message') {
+            const panel = events.find((x) => x.id === e.chat && x.type === 'chat');
+            if (!panel)
+                errors.push(`events[${e.order}] (${e.id}).chat: unknown chat ${e.chat}`);
+            else if (e.start < panel.start || e.start >= panel.end)
+                errors.push(`events[${e.order}] (${e.id}).at: outside chat ${e.chat}`);
+            else
+                e.end = panel.end;
         }
     }
     for (const cut of cuts) {
@@ -360,7 +369,7 @@ export function compile(scenario, regionIds) {
             errors.push(`cuts (${cut.id}).clockTransition: requires a previous cut`);
     }
     // Single-owner tracks cannot have ambiguous concurrent values. Independent layers can overlap.
-    for (const type of ['camera', 'inset', 'news', 'status', 'bulletin', 'legend']) {
+    for (const type of ['camera', 'inset', 'news', 'status', 'bulletin', 'legend', 'chat']) {
         const track = events.filter((e) => e.type === type).sort((a, b) => a.start - b.start);
         for (let i = 1; i < track.length; i++)
             if (track[i].start < track[i - 1].end)