dialog-ide 0.5.0

package/dist/dialoged/skein/service.js

@@ -0,0 +1,1097 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkeinService = void 0;
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const session_1 = require("./session");
+const compile_error_1 = require("./compile-error");
+const tree_1 = require("./tree");
+const render_1 = require("./ui/render");
+const search_1 = require("./search");
+const traceRender_1 = require("./ui/traceRender");
+const trace_1 = require("./trace");
+const syntax_1 = require("./syntax");
+const STATIC_CONTENT_TYPES = {
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.svg': 'image/svg+xml'
+};
+const NO_ACTIVE_SESSION_FRAGMENT = '<div id="skein-app" class="p-4">No skein session running.</div>';
+function readRequestBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+const SPECIAL_KEYSTROKES = new Set(['enter', 'space', 'backspace']);
+function normalizeKeystroke(text) {
+    if (text === ' ') {
+        return 'space';
+    }
+    if (text.length === 1 || SPECIAL_KEYSTROKES.has(text)) {
+        return text;
+    }
+    return null;
+}
+const SPINE_DIRECTIONS = new Set(['up', 'down', 'left', 'right', 'first', 'last']);
+function parseSpineDirection(payload) {
+    const { direction } = payload;
+    return typeof direction === 'string' && SPINE_DIRECTIONS.has(direction)
+        ? direction
+        : null;
+}
+const SEEKABLE_STATUSES = new Set(['new', 'error']);
+function parseSeekableStatus(payload) {
+    const { seekStatus } = payload;
+    return typeof seekStatus === 'string' && SEEKABLE_STATUSES.has(seekStatus)
+        ? seekStatus
+        : null;
+}
+function parseJsonBody(body) {
+    try {
+        const parsed = JSON.parse(body || '{}');
+        return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function parseKnotId(payload) {
+    const { knotId } = payload;
+    return typeof knotId === 'number' && Number.isInteger(knotId) ? knotId : null;
+}
+function parseNodeId(payload) {
+    const { nodeId } = payload;
+    return typeof nodeId === 'number' && Number.isInteger(nodeId) ? nodeId : null;
+}
+class SkeinService {
+    constructor(config) {
+        this.sessions = new Map();
+        this.isRunning = false;
+        this.sseClients = new Set();
+        this.onActiveSessionChange = () => this.broadcast();
+        this.cancelCurrentReplay = null;
+        this.currentProgress = null;
+        this.currentTrace = null;
+        this.searchQuery = '';
+        this.traceLoading = false;
+        this.traceSseClients = new Set();
+        this.grammarPromise = null;
+        this.config = config;
+    }
+    async start() {
+        if (this.isRunning) {
+            throw new Error('Service already running');
+        }
+        this.server = http.createServer((req, res) => {
+            this.handleRequest(req, res).catch((error) => {
+                console.error('Skein service request failed:', error);
+                if (!res.headersSent) {
+                    res.writeHead(500);
+                }
+                res.end();
+            });
+        });
+        await new Promise((resolve, reject) => {
+            this.server.once('error', reject);
+            this.server.listen(this.config.port, this.config.host, resolve);
+        });
+        const address = this.server.address();
+        this.port = typeof address === 'object' && address !== null ? address.port : this.config.port;
+        this.isRunning = true;
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        for (const session of this.sessions.values()) {
+            await session.stop();
+        }
+        this.sessions.clear();
+        for (const client of this.sseClients) {
+            client.end();
+        }
+        this.sseClients.clear();
+        for (const client of this.traceSseClients) {
+            client.end();
+        }
+        this.traceSseClients.clear();
+        if (this.activeSession) {
+            this.activeSession.offChange(this.onActiveSessionChange);
+            this.activeSession = undefined;
+            this.activeSessionId = undefined;
+        }
+        await new Promise((resolve, reject) => {
+            this.server.close((error) => (error ? reject(error) : resolve()));
+        });
+        this.server = undefined;
+        this.port = undefined;
+        this.isRunning = false;
+    }
+    getPort() {
+        if (this.port === undefined) {
+            throw new Error('Service is not running');
+        }
+        return this.port;
+    }
+    setActiveSession(session, sessionId, onSave) {
+        if (this.activeSession) {
+            this.activeSession.offChange(this.onActiveSessionChange);
+        }
+        this.activeSession = session;
+        this.activeSessionId = sessionId;
+        this.saveHandler = onSave;
+        if (this.activeSession) {
+            this.activeSession.onChange(this.onActiveSessionChange);
+        }
+        this.currentTrace = null;
+        this.traceLoading = false;
+        this.broadcastTrace();
+        this.searchQuery = '';
+        this.broadcast();
+    }
+    currentDisplayInfo() {
+        if (!this.activeSession || !this.activeSessionId) {
+            return undefined;
+        }
+        const tree = this.activeSession.getTree();
+        return { sessionId: this.activeSessionId, engine: tree.getEngine(), seed: tree.getSeed() };
+    }
+    currentSearchResults() {
+        const tree = this.activeSession?.getTree();
+        return tree ? (0, search_1.searchKnots)(tree, this.searchQuery) : { results: [], totalMatches: 0 };
+    }
+    async handleRequest(req, res) {
+        const url = new URL(req.url ?? '/', 'http://localhost');
+        if (url.pathname === '/') {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end((0, render_1.renderPage)(this.currentDisplayInfo(), this.activeSession?.getTree(), this.activeSession?.getGraphMenuId() ?? null, this.activeSession?.getTranscriptMenuId() ?? null, this.activeSession?.getShowDynamicState() ?? false, this.searchQuery, this.currentSearchResults(), this.activeSession?.getMarkerFilter() ?? null));
+            return;
+        }
+        if (url.pathname === '/events') {
+            this.handleSseConnect(res);
+            return;
+        }
+        if (url.pathname === '/trace') {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end((0, traceRender_1.renderTracePage)(this.currentTrace, this.traceLoading));
+            return;
+        }
+        if (url.pathname === '/trace/events') {
+            this.handleTraceSseConnect(res);
+            return;
+        }
+        if (url.pathname === '/trace/source-preview') {
+            await this.handleTraceSourcePreview(url, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/send-command') {
+            await this.handleSendCommand(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/send-keystroke') {
+            await this.handleSendKeystroke(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/select-knot') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.setActiveKnot(knotId), {
+                focusAfter: true
+            });
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/navigate-spine') {
+            await this.handleNavigateSpine(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/seek-status') {
+            await this.handleSeekStatus(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/new-child') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.newChild(knotId), { focusAfter: true });
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/open-graph-menu') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.openGraphMenu(knotId));
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/open-transcript-menu') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.openTranscriptMenu(knotId));
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/bless-knot') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.blessKnot(knotId), { flashMessage: 'Knot blessed' });
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/bless-changes') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.blessChanges(knotId), {
+                flashMessage: 'Transcript blessed'
+            });
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/toggle-lock') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.toggleLock(knotId));
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/toggle-tree-node') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.toggleTreeNode(knotId));
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/set-label') {
+            await this.handleSetLabel(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/set-marker') {
+            await this.handleSetMarker(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/set-marker-filter') {
+            await this.handleSetMarkerFilter(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/set-command') {
+            await this.handleSetCommand(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/insert-parent') {
+            await this.handleInsertParent(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/search') {
+            await this.handleSearch(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/delete-knot') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.deleteKnot(knotId));
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/splice-knot') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.spliceKnot(knotId));
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/replay-to') {
+            await this.handleKnotAction(req, res, (session, knotId) => session.replayToKnot(knotId), {
+                flashMessage: 'Replayed to knot'
+            });
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/cancel-replay') {
+            await this.handleCancelReplay(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/replay-all') {
+            await this.handleReplayAll(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/undo') {
+            await this.handleUndoRedo(req, res, (session) => session.undo());
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/redo') {
+            await this.handleUndoRedo(req, res, (session) => session.redo());
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/save') {
+            await this.handleSave(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/close-menus') {
+            await this.handleCloseMenus(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/toggle-dynamic-state') {
+            await this.handleToggleDynamicState(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/trace-knot') {
+            await this.handleTraceKnot(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/trace-startup') {
+            await this.handleTraceStartup(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/trace-search') {
+            await this.handleTraceSearch(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/trace-toggle-node') {
+            await this.handleTraceToggleNode(req, res);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/trace-expand-all') {
+            await this.handleTraceExpandCollapseAll(req, res, trace_1.expandAll);
+            return;
+        }
+        if (req.method === 'POST' && url.pathname === '/actions/trace-collapse-all') {
+            await this.handleTraceExpandCollapseAll(req, res, trace_1.collapseAll);
+            return;
+        }
+        if (url.pathname === '/style.css') {
+            await this.serveStaticFile(res, path.join(this.config.mediaRoot, 'style.css'));
+            return;
+        }
+        if (url.pathname === '/js/datastar.js') {
+            await this.serveStaticFile(res, path.join(this.config.mediaRoot, 'js', 'datastar.js'));
+            return;
+        }
+        if (url.pathname === '/js/main.js') {
+            await this.serveStaticFile(res, path.join(this.config.mediaRoot, 'js', 'main.js'));
+            return;
+        }
+        if (url.pathname === '/js/trace.js') {
+            await this.serveStaticFile(res, path.join(this.config.mediaRoot, 'js', 'trace.js'));
+            return;
+        }
+        if (url.pathname === '/js/skein-loader.js') {
+            await this.serveStaticFile(res, path.join(this.config.mediaRoot, 'js', 'skein-loader.js'));
+            return;
+        }
+        if (url.pathname === '/js/trace-loader.js') {
+            await this.serveStaticFile(res, path.join(this.config.mediaRoot, 'js', 'trace-loader.js'));
+            return;
+        }
+        if (url.pathname.startsWith('/icons/')) {
+            const name = path.basename(url.pathname.slice('/icons/'.length));
+            await this.serveStaticFile(res, path.join(this.config.mediaRoot, 'icons', name));
+            return;
+        }
+        res.writeHead(404);
+        res.end();
+    }
+    reportIfCompileError(error) {
+        if (error instanceof compile_error_1.DialogCompileError) {
+            this.config.onCompileError?.(error);
+        }
+    }
+    async handleSendCommand(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const signals = parseJsonBody(await readRequestBody(req));
+        const rawCommand = signals.newCommand;
+        const command = (0, session_1.normalizeCommand)(typeof rawCommand === 'string' ? rawCommand : '');
+        if (command === '') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        try {
+            await this.activeSession.runCommand(command);
+        }
+        catch (error) {
+            console.error('Failed to run command:', error);
+            this.reportIfCompileError(error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        this.broadcastScript('sk.resetAndFocusCommandInput()');
+        res.writeHead(204);
+        res.end();
+    }
+    async handleSendKeystroke(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const signals = parseJsonBody(await readRequestBody(req));
+        const rawKeystroke = signals.newKeystroke;
+        const keystroke = normalizeKeystroke(typeof rawKeystroke === 'string' ? rawKeystroke : '');
+        if (keystroke === null) {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        try {
+            await this.activeSession.runCommand(keystroke);
+        }
+        catch (error) {
+            console.error('Failed to send keystroke:', error);
+            this.reportIfCompileError(error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        this.broadcastScript('sk.resetAndFocusCommandInput()');
+        res.writeHead(204);
+        res.end();
+    }
+    async handleNavigateSpine(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const direction = parseSpineDirection(parseJsonBody(await readRequestBody(req)));
+        if (direction === null) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        try {
+            this.activeSession.navigateSpine(direction);
+        }
+        catch (error) {
+            console.error('Failed to navigate spine:', error);
+            this.reportIfCompileError(error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        const activeKnotId = this.activeSession.getTree().getActiveKnotId();
+        if (activeKnotId !== null) {
+            this.broadcastScript(`sk.resetAndFocusCommandInput(${activeKnotId})`);
+        }
+        res.writeHead(204);
+        res.end();
+    }
+    async handleSeekStatus(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const status = parseSeekableStatus(parseJsonBody(await readRequestBody(req)));
+        if (status === null) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        try {
+            this.activeSession.seekStatus(status);
+        }
+        catch (error) {
+            console.error('Failed to seek status:', error);
+            this.reportIfCompileError(error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        const activeKnotId = this.activeSession.getTree().getActiveKnotId();
+        if (activeKnotId !== null) {
+            this.broadcastScript(`sk.resetAndFocusCommandInput(${activeKnotId})`);
+        }
+        res.writeHead(204);
+        res.end();
+    }
+    async handleKnotAction(req, res, fn, options = {}) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const knotId = parseKnotId(parseJsonBody(await readRequestBody(req)));
+        if (knotId === null) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        try {
+            await fn(this.activeSession, knotId);
+        }
+        catch (error) {
+            this.activeSession.closeAllMenus();
+            if (error instanceof tree_1.KnotLockedError) {
+                this.broadcastFlash(error.message, 'error');
+                res.writeHead(409);
+                res.end();
+                return;
+            }
+            console.error('Knot action failed:', error);
+            this.reportIfCompileError(error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        if (options.flashMessage) {
+            this.broadcastFlash(options.flashMessage);
+        }
+        if (options.focusAfter) {
+            this.broadcastScript(`sk.resetAndFocusCommandInput(${knotId})`);
+        }
+        res.writeHead(204);
+        res.end();
+    }
+    async handleSetLabel(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const payload = parseJsonBody(await readRequestBody(req));
+        const knotId = parseKnotId(payload);
+        if (knotId === null) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const rawLabel = payload.label;
+        const label = typeof rawLabel === 'string' && rawLabel.trim() !== '' ? rawLabel.trim() : null;
+        try {
+            this.activeSession.setLabel(knotId, label);
+        }
+        catch (error) {
+            if (error instanceof tree_1.LabelConflictError) {
+                res.writeHead(409, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ error: error.message }));
+                return;
+            }
+            console.error('Failed to set label:', error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        res.writeHead(204);
+        res.end();
+    }
+    async handleSetMarker(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const payload = parseJsonBody(await readRequestBody(req));
+        const knotId = parseKnotId(payload);
+        if (knotId === null) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const marker = (0, tree_1.isValidMarker)(payload.marker) ? payload.marker : null;
+        try {
+            this.activeSession.setMarker(knotId, marker);
+        }
+        catch (error) {
+            console.error('Failed to set marker:', error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        res.writeHead(204);
+        res.end();
+    }
+    async handleSetMarkerFilter(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const payload = parseJsonBody(await readRequestBody(req));
+        if (!(0, tree_1.isValidMarker)(payload.marker)) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        this.activeSession.setMarkerFilter(payload.marker);
+        res.writeHead(204);
+        res.end();
+    }
+    async handleInsertParent(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const payload = parseJsonBody(await readRequestBody(req));
+        const knotId = parseKnotId(payload);
+        if (knotId === null) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const command = typeof payload.command === 'string' ? payload.command : '';
+        try {
+            await this.activeSession.insertParent(knotId, command);
+        }
+        catch (error) {
+            console.error('Failed to insert parent:', error);
+            this.reportIfCompileError(error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        const activeKnotId = this.activeSession.getTree().getActiveKnotId();
+        if (activeKnotId !== null) {
+            this.broadcastScript(`sk.resetAndFocusCommandInput(${activeKnotId})`);
+        }
+        res.writeHead(204);
+        res.end();
+    }
+    async handleSetCommand(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const payload = parseJsonBody(await readRequestBody(req));
+        const knotId = parseKnotId(payload);
+        if (knotId === null) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const command = typeof payload.command === 'string' ? payload.command : '';
+        try {
+            await this.activeSession.setCommand(knotId, command);
+        }
+        catch (error) {
+            console.error('Failed to set command:', error);
+            this.reportIfCompileError(error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        res.writeHead(204);
+        res.end();
+    }
+    async handleSearch(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const payload = parseJsonBody(await readRequestBody(req));
+        this.searchQuery = typeof payload.searchQuery === 'string' ? payload.searchQuery : '';
+        this.broadcast();
+        res.writeHead(204);
+        res.end();
+    }
+    async handleReplayAll(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        await readRequestBody(req);
+        try {
+            await this.activeSession.replayAll();
+        }
+        catch (error) {
+            console.error('Replay All failed:', error);
+            this.reportIfCompileError(error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        this.broadcastFlash('Replayed all paths');
+        res.writeHead(204);
+        res.end();
+    }
+    async handleCancelReplay(req, res) {
+        await readRequestBody(req);
+        this.cancelCurrentReplay?.();
+        res.writeHead(204);
+        res.end();
+    }
+    async handleSave(req, res) {
+        if (!this.activeSession || !this.saveHandler) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        await readRequestBody(req);
+        try {
+            await this.saveHandler();
+        }
+        catch (error) {
+            console.error('Failed to save session:', error);
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        res.writeHead(204);
+        res.end();
+    }
+    async handleCloseMenus(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        await readRequestBody(req);
+        this.activeSession.closeAllMenus();
+        res.writeHead(204);
+        res.end();
+    }
+    async handleToggleDynamicState(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        await readRequestBody(req);
+        this.activeSession.toggleShowDynamicState();
+        res.writeHead(204);
+        res.end();
+    }
+    async handleTraceKnot(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const knotId = parseKnotId(parseJsonBody(await readRequestBody(req)));
+        if (knotId === null) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        this.traceLoading = true;
+        this.config.onTraceRequested?.();
+        this.broadcastTrace();
+        let raw;
+        try {
+            raw = await this.activeSession.traceKnot(knotId);
+        }
+        catch (error) {
+            console.error('Trace knot failed:', error);
+            this.reportIfCompileError(error);
+            this.traceLoading = false;
+            this.broadcastTrace();
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        this.traceLoading = false;
+        if (raw === null) {
+            this.broadcastTrace();
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const knot = this.activeSession.getTree().getKnot(knotId);
+        this.currentTrace = {
+            tree: (0, trace_1.buildTraceTree)(raw),
+            commandLabel: knot?.command ?? '',
+            sourceKnotId: knotId,
+            searchTerm: '',
+            projectRoot: this.activeSession.getProjectRoot()
+        };
+        this.broadcastTrace();
+        res.writeHead(204);
+        res.end();
+    }
+    async handleTraceStartup(req, res) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        await readRequestBody(req);
+        this.traceLoading = true;
+        this.config.onTraceRequested?.();
+        this.broadcastTrace();
+        let raw;
+        try {
+            raw = await this.activeSession.traceStartup();
+        }
+        catch (error) {
+            console.error('Trace startup failed:', error);
+            this.reportIfCompileError(error);
+            this.traceLoading = false;
+            this.broadcastTrace();
+            res.writeHead(500);
+            res.end();
+            return;
+        }
+        this.traceLoading = false;
+        if (raw === null) {
+            this.broadcastTrace();
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        this.currentTrace = {
+            tree: (0, trace_1.buildTraceTree)(raw),
+            commandLabel: 'startup',
+            sourceKnotId: null,
+            searchTerm: '',
+            projectRoot: this.activeSession.getProjectRoot()
+        };
+        this.broadcastTrace();
+        res.writeHead(204);
+        res.end();
+    }
+    async handleTraceSearch(req, res) {
+        if (!this.currentTrace) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const payload = parseJsonBody(await readRequestBody(req));
+        const searchTerm = typeof payload.searchTerm === 'string' ? payload.searchTerm : '';
+        const searched = (0, trace_1.searchTree)(this.currentTrace.tree, searchTerm);
+        this.currentTrace = { ...this.currentTrace, tree: (0, trace_1.expandToMatches)(searched), searchTerm };
+        this.broadcastTrace();
+        res.writeHead(204);
+        res.end();
+    }
+    async handleTraceToggleNode(req, res) {
+        if (!this.currentTrace) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        const nodeId = parseNodeId(parseJsonBody(await readRequestBody(req)));
+        if (nodeId === null) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        this.currentTrace = { ...this.currentTrace, tree: (0, trace_1.toggleExpanded)(this.currentTrace.tree, nodeId) };
+        this.broadcastTrace();
+        res.writeHead(204);
+        res.end();
+    }
+    async handleTraceExpandCollapseAll(req, res, fn) {
+        if (!this.currentTrace) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        await readRequestBody(req);
+        this.currentTrace = { ...this.currentTrace, tree: fn(this.currentTrace.tree) };
+        this.broadcastTrace();
+        res.writeHead(204);
+        res.end();
+    }
+    async handleTraceSourcePreview(url, res) {
+        const nodeIdParam = url.searchParams.get('nodeId');
+        const nodeId = nodeIdParam !== null ? Number(nodeIdParam) : NaN;
+        if (!this.currentTrace || !this.activeSession || Number.isNaN(nodeId)) {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Source not found');
+            return;
+        }
+        const node = (0, trace_1.getNode)(this.currentTrace.tree, nodeId);
+        const parsed = node?.source ? (0, trace_1.parseSource)(node.source) : null;
+        if (!parsed) {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Source not found');
+            return;
+        }
+        const [filePath, line] = parsed;
+        const resolvedPath = path.resolve(this.activeSession.getProjectRoot(), filePath);
+        let content;
+        try {
+            content = await fs.readFile(resolvedPath, 'utf8');
+        }
+        catch {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Source not found');
+            return;
+        }
+        const allLines = content.split('\n');
+        const context = 4;
+        const start = Math.max(0, line - context - 1);
+        const end = Math.min(allLines.length, line + context);
+        const html = this.config.grammarPath
+            ? (0, syntax_1.renderHighlightedSnippet)(await this.getGrammar(), allLines, start, end, line)
+            : (0, syntax_1.renderPlainSnippet)(allLines, start, end, line);
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(html);
+    }
+    getGrammar() {
+        if (!this.grammarPromise) {
+            this.grammarPromise = (0, syntax_1.loadDialogGrammar)(this.config.grammarPath);
+        }
+        return this.grammarPromise;
+    }
+    async handleUndoRedo(req, res, fn) {
+        if (!this.activeSession) {
+            res.writeHead(400);
+            res.end();
+            return;
+        }
+        await readRequestBody(req);
+        fn(this.activeSession);
+        res.writeHead(204);
+        res.end();
+    }
+    handleSseConnect(res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive'
+        });
+        this.sseClients.add(res);
+        res.on('close', () => this.sseClients.delete(res));
+        this.sendPatch(res);
+        this.sendScript(res, 'sk.resetAndFocusCommandInput()');
+        if (this.currentProgress) {
+            const { title, cancellable, percent, message } = this.currentProgress;
+            this.sendScript(res, `sk.showProgress(${JSON.stringify(title)}, ${JSON.stringify(cancellable)})`);
+            this.sendScript(res, `sk.updateProgress(${percent}, ${JSON.stringify(message)})`);
+        }
+    }
+    broadcast() {
+        for (const client of this.sseClients) {
+            this.sendPatch(client);
+        }
+    }
+    handleTraceSseConnect(res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive'
+        });
+        this.traceSseClients.add(res);
+        res.on('close', () => this.traceSseClients.delete(res));
+        this.sendTracePatch(res);
+    }
+    broadcastTrace() {
+        for (const client of this.traceSseClients) {
+            this.sendTracePatch(client);
+        }
+    }
+    sendTracePatch(res) {
+        if (res.writableEnded) {
+            return;
+        }
+        const html = (0, traceRender_1.renderTraceApp)(this.currentTrace, this.traceLoading);
+        const dataLines = html
+            .split('\n')
+            .map((line) => `data: elements ${line}`)
+            .join('\n');
+        res.write(`event: datastar-patch-elements\n${dataLines}\n\n`);
+    }
+    sendPatch(res) {
+        if (res.writableEnded) {
+            return;
+        }
+        const info = this.currentDisplayInfo();
+        const tree = this.activeSession?.getTree();
+        const html = info && tree
+            ? (0, render_1.renderApp)(info, tree, this.activeSession.getGraphMenuId(), this.activeSession.getTranscriptMenuId(), this.activeSession.getShowDynamicState(), this.searchQuery, this.currentSearchResults(), this.activeSession.getMarkerFilter())
+            : NO_ACTIVE_SESSION_FRAGMENT;
+        const dataLines = html
+            .split('\n')
+            .map((line) => `data: elements ${line}`)
+            .join('\n');
+        res.write(`event: datastar-patch-elements\n${dataLines}\n\n`);
+    }
+    broadcastScript(js) {
+        for (const client of this.sseClients) {
+            this.sendScript(client, js);
+        }
+    }
+    broadcastFlash(message, type = 'info') {
+        const args = type === 'info' ? JSON.stringify(message) : `${JSON.stringify(message)}, ${JSON.stringify(type)}`;
+        this.broadcastScript(`sk.showFlash(${args})`);
+    }
+    async withProgress(options, task) {
+        const token = { isCancellationRequested: false };
+        this.cancelCurrentReplay = () => {
+            token.isCancellationRequested = true;
+        };
+        this.currentProgress = { title: options.title, cancellable: options.cancellable, percent: 0, message: null };
+        this.broadcastScript(`sk.showProgress(${JSON.stringify(options.title)}, ${JSON.stringify(options.cancellable)})`);
+        const progress = {
+            report: (update) => {
+                const percent = Math.min(100, this.currentProgress.percent + (update.increment ?? 0));
+                const message = update.message ?? null;
+                this.currentProgress = { ...this.currentProgress, percent, message };
+                this.broadcastScript(`sk.updateProgress(${percent}, ${JSON.stringify(message)})`);
+            }
+        };
+        try {
+            return await task(progress, token);
+        }
+        finally {
+            this.cancelCurrentReplay = null;
+            this.currentProgress = null;
+            this.broadcastScript('sk.hideProgress()');
+        }
+    }
+    sendScript(res, js) {
+        if (res.writableEnded) {
+            return;
+        }
+        res.write('event: datastar-patch-elements\n' +
+            'data: mode append\n' +
+            'data: selector body\n' +
+            `data: elements <script data-effect="el.remove()">${js}</script>\n\n`);
+    }
+    async serveStaticFile(res, filePath) {
+        try {
+            const content = await fs.readFile(filePath);
+            const contentType = STATIC_CONTENT_TYPES[path.extname(filePath)] ?? 'application/octet-stream';
+            res.writeHead(200, { 'Content-Type': contentType });
+            res.end(content);
+        }
+        catch {
+            res.writeHead(404);
+            res.end();
+        }
+    }
+    createSession(config) {
+        const session = session_1.SkeinSession.createNew(config);
+        this.sessions.set(session.getId(), session);
+        return session;
+    }
+    loadSession(tree, config) {
+        const session = session_1.SkeinSession.createLoaded(tree, config);
+        this.sessions.set(session.getId(), session);
+        return session;
+    }
+    getSession(id) {
+        return this.sessions.get(id) || null;
+    }
+    getAllSessions() {
+        return Array.from(this.sessions.values());
+    }
+    async handleSkeinEndpoints() {
+        console.log('Handling skein endpoints...');
+    }
+    serveUiComponents() {
+        console.log('Serving UI components...');
+    }
+    sendSseUpdate(event) {
+        console.log(`Sending SSE update: ${event.type}`, event.data);
+    }
+    isRunningService() {
+        return this.isRunning;
+    }
+}
+exports.SkeinService = SkeinService;
+//# sourceMappingURL=service.js.map