dialog-ide 0.5.0

package/dist/extension.js

@@ -0,0 +1,885 @@
+"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.activate = activate;
+exports.deactivate = deactivate;
+const path = __importStar(require("path"));
+const vscode = __importStar(require("vscode"));
+const skein_1 = require("./dialoged/skein");
+const dialog_symbol_provider_1 = require("./dialog-symbol-provider");
+const dialog_workspace_watcher_1 = require("./dialog-workspace-watcher");
+const dialog_workspace_symbol_provider_1 = require("./dialog-workspace-symbol-provider");
+const dialog_source_decoration_provider_1 = require("./dialog-source-decoration-provider");
+const dialog_source_coverage_1 = require("./dialog-source-coverage");
+const dialog_project_init_1 = require("./dialog-project-init");
+const dialog_export_1 = require("./dialog-export");
+const dialog_web_export_1 = require("./dialog-web-export");
+const dialog_feelies_1 = require("./dialog-feelies");
+const session_runner_1 = require("./session-runner");
+const EXPORT_FORMATS = ['zblorb', 'z8', 'aa'];
+let skeinService;
+let skeinPanel;
+let statusBarItem;
+let activeSession;
+let activeSessionId;
+let activeProjectRoot;
+let suppressReloadPromptUntil = 0;
+let testTerminal;
+let bundledBinDir;
+let bundledLibraryDir;
+let patchSourcePath;
+let deactivating = false;
+let compileErrorDiagnostics;
+function clearCompileErrorDiagnostics() {
+    compileErrorDiagnostics?.clear();
+}
+async function isEngineAvailable(engine, binDir) {
+    return engine === 'dgdebug' ? (0, session_runner_1.isDgdebugAvailable)(binDir, bundledBinDir) : (0, session_runner_1.isDialogcAvailable)(binDir, bundledBinDir);
+}
+function engineUnavailableMessage(engine) {
+    const command = engine === 'dgdebug' ? 'dgdebug' : 'dialogc';
+    return `${command} was not found on PATH, in binDir, or bundled with this extension. Install the Dialog toolchain or set "binDir" in dialog.json.`;
+}
+async function activate(context) {
+    bundledBinDir = (0, skein_1.resolveBundledBinDir)(context.extensionPath);
+    bundledLibraryDir = (0, skein_1.resolveBundledLibraryDir)(context.extensionPath);
+    patchSourcePath = path.join(context.extensionPath, 'resources', 'dfrotz-skein-patch.dg');
+    compileErrorDiagnostics = vscode.languages.createDiagnosticCollection('dialog-compile-error');
+    context.subscriptions.push(compileErrorDiagnostics);
+    skeinService = new skein_1.SkeinService({
+        port: 0,
+        host: 'localhost',
+        mediaRoot: path.join(context.extensionPath, 'media'),
+        grammarPath: resolveDialogGrammarPath(context),
+        onCompileError: (error) => {
+            handleCompileError(error).catch((handlerError) => {
+                console.error('Failed to report compile error:', handlerError);
+            });
+        },
+        onTraceRequested: () => {
+            vscode.commands.executeCommand('dialogIdeTraceView.focus').then(undefined, (error) => {
+                console.error('Failed to reveal the Trace view:', error);
+            });
+        }
+    });
+    await skeinService.start();
+    statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 100);
+    refreshStatusBar();
+    statusBarItem.show();
+    context.subscriptions.push(statusBarItem);
+    context.subscriptions.push(vscode.window.registerWebviewViewProvider('dialogIdeTraceView', new TraceViewProvider(), {
+        webviewOptions: { retainContextWhenHidden: true }
+    }));
+    context.subscriptions.push(vscode.languages.registerDocumentSymbolProvider({ language: 'dialog' }, new dialog_symbol_provider_1.DialogDocumentSymbolProvider()));
+    const workspaceWatcher = new dialog_workspace_watcher_1.DialogWorkspaceWatcher(getWorkspaceRoot());
+    const workspaceSymbolProvider = new dialog_workspace_symbol_provider_1.DialogWorkspaceSymbolProvider(workspaceWatcher);
+    context.subscriptions.push(workspaceWatcher, workspaceSymbolProvider, vscode.languages.registerWorkspaceSymbolProvider(workspaceSymbolProvider));
+    const sourceDecorationProvider = new dialog_source_decoration_provider_1.DialogSourceDecorationProvider(getWorkspaceRoot);
+    context.subscriptions.push(sourceDecorationProvider, vscode.window.registerFileDecorationProvider(sourceDecorationProvider));
+    context.subscriptions.push(workspaceWatcher.onDidChangeFiles((event) => {
+        activeSession?.markSourcesChanged();
+        if (event.type === 'create' || event.type === 'delete') {
+            sourceDecorationProvider.refresh([event.filePath]);
+        }
+        if (event.type === 'create') {
+            warnIfUncoveredSource(getWorkspaceRoot(), event.filePath).catch((error) => {
+                console.error('Failed to check dialog.json source coverage:', error);
+            });
+        }
+    }), workspaceWatcher.onDidChangeProjectConfig(() => {
+        activeSession?.markSourcesChanged();
+        sourceDecorationProvider.refresh(workspaceWatcher.listFiles());
+        warnIfDuplicateSources(getWorkspaceRoot()).catch((error) => {
+            console.error('Failed to check dialog.json for duplicate sources:', error);
+        });
+    }));
+    const workspaceRoot = getWorkspaceRoot();
+    if (workspaceRoot) {
+        const skeinFileWatcher = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(workspaceRoot, '**/*.skein'));
+        context.subscriptions.push(skeinFileWatcher, skeinFileWatcher.onDidChange(handleSkeinFileChangedOnDisk));
+    }
+    context.subscriptions.push(vscode.commands.registerCommand('dialog-ide.openSkein', () => ensureSkeinPanel()), vscode.commands.registerCommand('dialog-ide.runDefaultSkein', withErrorHandling(() => runDefaultSkein((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot())))), vscode.commands.registerCommand('dialog-ide.runSkein', withErrorHandling(() => runSkeinPicker((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot())))), vscode.commands.registerCommand('dialog-ide.newSkein', withErrorHandling(() => newSkeinSession((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot())))), vscode.commands.registerCommand('dialog-ide.stopSkein', withErrorHandling(stopSkeinCommand)), vscode.commands.registerCommand('dialog-ide.saveSkein', withErrorHandling(saveActiveSession)), vscode.commands.registerCommand('dialog-ide.debugInTerminal', withErrorHandling(() => debugInTerminal((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot())))), vscode.commands.registerCommand('dialog-ide.runTests', withErrorHandling(() => runTestsInTerminal((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot())))), vscode.commands.registerCommand('dialog-ide.addSourceToProject', withErrorHandling((filePath) => addSourceToProject((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot()), filePath ?? activeEditorDgFilePath()))), vscode.commands.registerCommand('dialog-ide.initProject', withErrorHandling(() => initDialogProject((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot()), bundledLibraryDir, path.join(context.extensionPath, 'resources', 'bundle', 'default-cover.png'), path.join(context.extensionPath, 'resources', 'bundle')))), vscode.commands.registerCommand('dialog-ide.configureExports', withErrorHandling(() => configureExports((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot())))), vscode.commands.registerCommand('dialog-ide.exportProject', withErrorHandling(() => exportDialogProject((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot())))), vscode.commands.registerCommand('dialog-ide.exportWebPage', withErrorHandling(() => exportWebPage((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot()), path.join(context.extensionPath, 'resources', 'bundle')))), vscode.commands.registerCommand('dialog-ide.addFeelie', withErrorHandling((uri) => addFeelieWizard((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot()), uri?.fsPath))), vscode.commands.registerCommand('dialog-ide.removeFeelie', withErrorHandling(() => removeFeelieWizard((0, session_runner_1.resolveProjectRoot)(getWorkspaceRoot())))));
+    warnAboutConflictingLanguageExtension(context);
+}
+async function deactivate() {
+    deactivating = true;
+    await stopActiveSession();
+    await skeinService?.stop();
+    skeinService = undefined;
+}
+function withErrorHandling(action) {
+    return async (...args) => {
+        try {
+            await action(...args);
+        }
+        catch (error) {
+            vscode.window.showErrorMessage(error instanceof Error ? error.message : String(error));
+        }
+    };
+}
+function getWorkspaceRoot() {
+    return vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+}
+async function runDefaultSkein(projectRoot) {
+    const manager = new skein_1.PersistenceManager(projectRoot);
+    if (!(await manager.sessionExists(session_runner_1.DEFAULT_SESSION_ID))) {
+        throw new Error(`${session_runner_1.DEFAULT_SESSION_ID}.skein does not exist - use "New Skein..." instead.`);
+    }
+    await runLoadedSession(projectRoot, session_runner_1.DEFAULT_SESSION_ID);
+}
+async function runSkeinPicker(projectRoot) {
+    const ids = await (0, session_runner_1.listSkeinFiles)(projectRoot);
+    if (ids.length === 0) {
+        throw new Error('No .skein files found in this project - use "New Skein..." to create one.');
+    }
+    const picked = await vscode.window.showQuickPick(ids.map((id) => `${id}.skein`), { placeHolder: 'Choose a skein file to run' });
+    if (!picked) {
+        return;
+    }
+    await runLoadedSession(projectRoot, (0, session_runner_1.toSessionId)(picked));
+}
+async function runLoadedSession(projectRoot, sessionId) {
+    if (!(await confirmStopIfRunning())) {
+        return;
+    }
+    await loadAndActivateSession(projectRoot, sessionId, 'Running');
+}
+async function loadAndActivateSession(projectRoot, sessionId, verb) {
+    const project = (0, skein_1.readProject)(projectRoot);
+    const manager = new skein_1.PersistenceManager(projectRoot);
+    const tree = await manager.loadSession(sessionId);
+    if (!(await isEngineAvailable(tree.getEngine(), project.binDir))) {
+        throw new Error(engineUnavailableMessage(tree.getEngine()));
+    }
+    const session = skein_1.SkeinSession.createLoaded(tree, (0, session_runner_1.sessionConfigFromTree)(tree, projectRoot, bundledBinDir, patchSourcePath), skeinService);
+    if (!(await runSessionStep(() => session.start()))) {
+        return;
+    }
+    setActiveSession(session, sessionId, projectRoot);
+    vscode.window.showInformationMessage(`${verb} ${sessionId}.skein (${tree.getEngine()})`);
+    const activeKnotId = session.getTree().getActiveKnotId();
+    if (activeKnotId !== null && activeKnotId !== 0) {
+        await runSessionStep(() => session.replayAll());
+    }
+}
+async function reloadActiveSessionFromDisk() {
+    if (!activeSession || !activeSessionId || !activeProjectRoot) {
+        return;
+    }
+    const sessionId = activeSessionId;
+    const projectRoot = activeProjectRoot;
+    await stopActiveSession();
+    await loadAndActivateSession(projectRoot, sessionId, 'Reloaded');
+}
+function handleSkeinFileChangedOnDisk(uri) {
+    if (!activeSession || !activeSessionId || !activeProjectRoot) {
+        return;
+    }
+    if (Date.now() < suppressReloadPromptUntil) {
+        return;
+    }
+    if (uri.fsPath !== path.join(activeProjectRoot, `${activeSessionId}.skein`)) {
+        return;
+    }
+    vscode.window
+        .showWarningMessage(`"${activeSessionId}.skein" was changed on disk outside Dialog IDE. Reload it? This discards any unsaved changes in the running session.`, { modal: true }, 'Reload')
+        .then((choice) => {
+        if (choice === 'Reload') {
+            reloadActiveSessionFromDisk().catch((error) => {
+                vscode.window.showErrorMessage(`Failed to reload skein: ${error.message}`);
+            });
+        }
+    });
+}
+async function newSkeinSession(projectRoot) {
+    if (!(await confirmStopIfRunning())) {
+        return;
+    }
+    const engineChoice = await pickEngine();
+    if (!engineChoice) {
+        return;
+    }
+    const seedInput = await vscode.window.showInputBox({
+        prompt: 'Random seed (leave blank for a random one)',
+        validateInput: (value) => {
+            if (value.trim() === '') {
+                return undefined;
+            }
+            try {
+                (0, session_runner_1.parseSeed)(value);
+                return undefined;
+            }
+            catch (error) {
+                return error.message;
+            }
+        }
+    });
+    if (seedInput === undefined) {
+        return;
+    }
+    const seed = seedInput.trim() === '' ? (0, session_runner_1.randomSeed)() : (0, session_runner_1.parseSeed)(seedInput);
+    const filenameInput = await vscode.window.showInputBox({
+        prompt: 'Skein file name',
+        value: `${session_runner_1.DEFAULT_SESSION_ID}.skein`,
+        validateInput: (value) => ((0, session_runner_1.isValidSessionId)((0, session_runner_1.toSessionId)(value)) ? undefined : 'Enter a plain file name, not a path.')
+    });
+    if (filenameInput === undefined) {
+        return;
+    }
+    const sessionId = (0, session_runner_1.toSessionId)(filenameInput);
+    const manager = new skein_1.PersistenceManager(projectRoot);
+    if (await manager.sessionExists(sessionId)) {
+        throw new Error(`${sessionId}.skein already exists - use "Run Skein..." to open it instead.`);
+    }
+    const project = (0, skein_1.readProject)(projectRoot);
+    if (!(await isEngineAvailable(engineChoice.engine, project.binDir))) {
+        throw new Error(engineUnavailableMessage(engineChoice.engine));
+    }
+    const session = skein_1.SkeinSession.createNew({ engine: engineChoice.engine, seed, projectRoot, bundledBinDir, patchSourcePath }, skeinService);
+    if (!(await runSessionStep(() => session.start()))) {
+        return;
+    }
+    await manager.saveSession(session.getTree(), sessionId);
+    setActiveSession(session, sessionId, projectRoot);
+    vscode.window.showInformationMessage(`Started ${sessionId}.skein (${engineChoice.engine}, seed ${seed})`);
+}
+async function pickEngine() {
+    for (;;) {
+        const picked = await vscode.window.showQuickPick(session_runner_1.ENGINE_CHOICES.map((choice) => ({
+            label: choice.label,
+            description: choice.supported ? undefined : 'not yet implemented',
+            choice
+        })), { placeHolder: 'Choose an engine' });
+        if (!picked) {
+            return undefined;
+        }
+        if (!picked.choice.supported) {
+            vscode.window.showInformationMessage(`${picked.choice.label} isn't implemented yet - choose dgdebug.`);
+            continue;
+        }
+        return picked.choice;
+    }
+}
+async function stopSkeinCommand() {
+    if (!activeSession) {
+        vscode.window.showInformationMessage('No skein session is running.');
+        return;
+    }
+    await stopActiveSession();
+    vscode.window.showInformationMessage('Skein session stopped.');
+}
+async function saveActiveSession() {
+    if (!activeSession || !activeSessionId || !activeProjectRoot) {
+        vscode.window.showInformationMessage('No skein session is running.');
+        return;
+    }
+    suppressReloadPromptUntil = Date.now() + 2000;
+    await new skein_1.PersistenceManager(activeProjectRoot).saveSession(activeSession.getTree(), activeSessionId);
+    vscode.window.showInformationMessage(`Saved ${activeSessionId}.skein`);
+}
+async function debugInTerminal(projectRoot) {
+    const project = (0, skein_1.readProject)(projectRoot);
+    if (!(await (0, session_runner_1.isDgdebugAvailable)(project.binDir, bundledBinDir))) {
+        throw new Error('dgdebug was not found on PATH, in binDir, or bundled with this extension. Install the Dialog toolchain or set "binDir" in dialog.json.');
+    }
+    const sourceFiles = (0, skein_1.expandSources)(project, { debug: true, target: 'dgdebug' });
+    const terminal = vscode.window.createTerminal({
+        name: 'Dialog Debugger',
+        shellPath: (0, skein_1.resolveCommandPath)(project.binDir, 'dgdebug', bundledBinDir),
+        shellArgs: (0, session_runner_1.debugTerminalShellArgs)(sourceFiles)
+    });
+    terminal.show();
+}
+async function runTestsInTerminal(projectRoot) {
+    const project = (0, skein_1.readProject)(projectRoot);
+    if (!(await (0, session_runner_1.isDgdebugAvailable)(project.binDir, bundledBinDir))) {
+        throw new Error('dgdebug was not found on PATH, in binDir, or bundled with this extension. Install the Dialog toolchain or set "binDir" in dialog.json.');
+    }
+    testTerminal?.dispose();
+    const sourceFiles = (0, skein_1.expandSources)(project, { debug: true, test: true, target: 'dgdebug' });
+    testTerminal = vscode.window.createTerminal({
+        name: 'Dialog Tests',
+        shellPath: (0, skein_1.resolveCommandPath)(project.binDir, 'dgdebug', bundledBinDir),
+        shellArgs: (0, session_runner_1.testTerminalShellArgs)(sourceFiles)
+    });
+    testTerminal.show();
+}
+async function warnIfUncoveredSource(rootDir, filePath) {
+    if (!rootDir || !vscode.workspace.getConfiguration('dialog-ide').get('warnOnUncoveredSource', true)) {
+        return;
+    }
+    let project;
+    try {
+        project = (0, skein_1.readProject)(rootDir);
+    }
+    catch {
+        return;
+    }
+    if ((0, skein_1.isFileCoveredBySource)(project, filePath)) {
+        return;
+    }
+    const choice = await vscode.window.showWarningMessage(`${path.basename(filePath)} isn't part of any dialog.json source - it won't be compiled.`, 'Add to dialog.json');
+    if (choice === 'Add to dialog.json') {
+        await vscode.commands.executeCommand('dialog-ide.addSourceToProject', filePath);
+    }
+}
+async function warnIfDuplicateSources(rootDir) {
+    if (!rootDir || !vscode.workspace.getConfiguration('dialog-ide').get('warnOnDuplicateSource', true)) {
+        return;
+    }
+    let project;
+    try {
+        project = (0, skein_1.readProject)(rootDir);
+    }
+    catch {
+        return;
+    }
+    const duplicates = (0, skein_1.findDuplicateSourceFiles)(project);
+    if (duplicates.length === 0) {
+        return;
+    }
+    const summary = duplicates
+        .map(({ filePath, categories }) => `${path.basename(filePath)} (${categories.join(', ')})`)
+        .join(', ');
+    const choice = await vscode.window.showWarningMessage(`dialog.json declares the same source more than once: ${summary}. Dialog would compile it twice.`, 'Open dialog.json');
+    if (choice === 'Open dialog.json') {
+        const document = await vscode.workspace.openTextDocument(path.join(rootDir, 'dialog.json'));
+        await vscode.window.showTextDocument(document);
+    }
+}
+function activeEditorDgFilePath() {
+    const document = vscode.window.activeTextEditor?.document;
+    return document && document.fileName.endsWith('.dg') ? document.fileName : undefined;
+}
+async function addSourceToProject(projectRoot, filePath) {
+    if (!filePath) {
+        throw new Error('No .dg file to add - open one first, or use this from the "not covered by dialog.json" warning.');
+    }
+    const picked = await vscode.window.showQuickPick(dialog_source_coverage_1.SOURCE_CATEGORIES.map(({ category, description }) => ({ label: category, description, category })), { placeHolder: 'Add to which dialog.json source category?' });
+    if (!picked) {
+        return;
+    }
+    const dialogJsonPath = path.join(projectRoot, 'dialog.json');
+    const relativePath = (0, dialog_source_coverage_1.toDialogJsonPath)(projectRoot, filePath);
+    (0, dialog_source_coverage_1.addSourceToDialogJson)(dialogJsonPath, picked.category, relativePath);
+    vscode.window.showInformationMessage(`Added ${relativePath} to dialog.json's "${picked.category}" sources.`);
+}
+async function initDialogProject(projectRoot, libraryDir, coverImageSource, pdfAssetsDir) {
+    const name = await vscode.window.showInputBox({
+        prompt: 'Dialog project name',
+        value: path.basename(projectRoot),
+        validateInput: (value) => (value.trim() === '' ? 'Enter a project name.' : undefined)
+    });
+    if (name === undefined) {
+        return;
+    }
+    (0, dialog_project_init_1.scaffoldProject)(projectRoot, { name: name.trim() }, libraryDir, coverImageSource, pdfAssetsDir);
+    const storyDgPath = path.join(projectRoot, 'main', 'story.dg');
+    await vscode.window.showTextDocument(await vscode.workspace.openTextDocument(storyDgPath));
+    vscode.window.showInformationMessage(`Initialized Dialog project "${name.trim()}" in ${projectRoot}.`);
+}
+async function configureExports(projectRoot) {
+    const dialogJsonPath = path.join(projectRoot, 'dialog.json');
+    for (;;) {
+        const project = (0, skein_1.readProject)(projectRoot);
+        const items = [
+            { label: '$(add) Add new export configuration...', action: 'add' },
+            ...project.exports.map((config) => ({
+                label: config.name,
+                description: `${config.format}${config.includeDebug ? ', debug' : ''} → ${config.output}`,
+                action: 'remove',
+                name: config.name
+            })),
+            {
+                label: '$(gear) Set default dialogc options...',
+                description: project.dialogcOptions ? project.dialogcOptions.join(' ') : '(none)',
+                action: 'options'
+            },
+            { label: '$(check) Done', action: 'done' }
+        ];
+        const picked = await vscode.window.showQuickPick(items, {
+            placeHolder: 'Configure Dialog project exports'
+        });
+        if (!picked || picked.action === 'done') {
+            return;
+        }
+        if (picked.action === 'add') {
+            await addExportConfigWizard(dialogJsonPath, project);
+        }
+        else if (picked.action === 'options') {
+            await editProjectDialogcOptionsWizard(dialogJsonPath, project);
+        }
+        else if (picked.name) {
+            await removeExportConfigWizard(dialogJsonPath, picked.name);
+        }
+    }
+}
+async function editProjectDialogcOptionsWizard(dialogJsonPath, project) {
+    const raw = await vscode.window.showInputBox({
+        prompt: 'Default dialogc options for this project (e.g. --heap 2000 --aux 1000) - leave blank to clear',
+        value: project.dialogcOptions ? project.dialogcOptions.join(' ') : ''
+    });
+    if (raw === undefined) {
+        return;
+    }
+    (0, dialog_export_1.setProjectDialogcOptions)(dialogJsonPath, (0, dialog_export_1.parseDialogcOptionsInput)(raw));
+    vscode.window.showInformationMessage(raw.trim() === '' ? 'Cleared the project\'s default dialogc options.' : 'Updated the project\'s default dialogc options.');
+}
+async function addExportConfigWizard(dialogJsonPath, project) {
+    const name = await vscode.window.showInputBox({
+        prompt: 'Export configuration name',
+        validateInput: (value) => {
+            const trimmed = value.trim();
+            if (trimmed === '') {
+                return 'Enter a name.';
+            }
+            return project.exports.some((entry) => entry.name === trimmed) ? `"${trimmed}" already exists.` : undefined;
+        }
+    });
+    if (!name) {
+        return;
+    }
+    const formatChoice = await vscode.window.showQuickPick(EXPORT_FORMATS, { placeHolder: 'Output format' });
+    if (!formatChoice) {
+        return;
+    }
+    const format = formatChoice;
+    const includeDebugChoice = await vscode.window.showQuickPick(['No', 'Yes'], {
+        placeHolder: 'Include debug sources? (usually No for a release build)'
+    });
+    if (!includeDebugChoice) {
+        return;
+    }
+    const draft = { name: name.trim(), format, includeDebug: includeDebugChoice === 'Yes', output: '' };
+    const output = await vscode.window.showInputBox({
+        prompt: 'Output path (relative to the project root)',
+        value: (0, dialog_export_1.defaultOutputPath)(draft)
+    });
+    if (!output) {
+        return;
+    }
+    const dialogcOptionsRaw = await vscode.window.showInputBox({
+        prompt: 'Extra dialogc options for this export (e.g. --heap 2000 --aux 1000) - leave blank to use the project\'s default, if any'
+    });
+    if (dialogcOptionsRaw === undefined) {
+        return;
+    }
+    const dialogcOptions = (0, dialog_export_1.parseDialogcOptionsInput)(dialogcOptionsRaw);
+    (0, dialog_export_1.addExportConfig)(dialogJsonPath, {
+        ...draft,
+        output,
+        ...(dialogcOptions.length > 0 ? { dialogcOptions } : {})
+    });
+    vscode.window.showInformationMessage(`Added export configuration "${draft.name}".`);
+}
+async function removeExportConfigWizard(dialogJsonPath, name) {
+    const choice = await vscode.window.showQuickPick(['Remove', 'Cancel'], {
+        placeHolder: `Remove export configuration "${name}"?`
+    });
+    if (choice !== 'Remove') {
+        return;
+    }
+    (0, dialog_export_1.removeExportConfig)(dialogJsonPath, name);
+    vscode.window.showInformationMessage(`Removed export configuration "${name}".`);
+}
+async function addFeelieWizard(projectRoot, filePath) {
+    if (!filePath) {
+        const picked = await vscode.window.showOpenDialog({
+            defaultUri: vscode.Uri.file(projectRoot),
+            canSelectMany: false,
+            openLabel: 'Add Feelie',
+            filters: { 'PDF files': ['pdf'], 'All files': ['*'] }
+        });
+        if (!picked || picked.length === 0) {
+            return;
+        }
+        filePath = picked[0].fsPath;
+    }
+    const dialogJsonPath = path.join(projectRoot, 'dialog.json');
+    const feeliePath = (0, dialog_source_coverage_1.toDialogJsonPath)(projectRoot, filePath);
+    const name = await vscode.window.showInputBox({
+        prompt: 'Feelie display name (the link text on the exported page)',
+        value: path.basename(filePath, path.extname(filePath)),
+        validateInput: (value) => (value.trim() === '' ? 'Enter a name.' : undefined)
+    });
+    if (!name) {
+        return;
+    }
+    const feelie = { path: feeliePath, name: name.trim() };
+    (0, dialog_feelies_1.addFeelie)(dialogJsonPath, feelie);
+    vscode.window.showInformationMessage(`Added feelie "${feelie.name}".`);
+}
+async function removeFeelieWizard(projectRoot) {
+    const dialogJsonPath = path.join(projectRoot, 'dialog.json');
+    const project = (0, skein_1.readProject)(projectRoot);
+    const feelies = project.feelies ?? [];
+    if (feelies.length === 0) {
+        vscode.window.showInformationMessage('This project has no feelies configured.');
+        return;
+    }
+    const picked = await vscode.window.showQuickPick(feelies.map((feelie) => ({ label: feelie.name, description: feelie.path, feelie })), { placeHolder: 'Remove which feelie?' });
+    if (!picked) {
+        return;
+    }
+    const choice = await vscode.window.showQuickPick(['Remove', 'Cancel'], {
+        placeHolder: `Remove feelie "${picked.feelie.name}"?`
+    });
+    if (choice !== 'Remove') {
+        return;
+    }
+    (0, dialog_feelies_1.removeFeelie)(dialogJsonPath, picked.feelie.path);
+    vscode.window.showInformationMessage(`Removed feelie "${picked.feelie.name}".`);
+}
+function revealFileLabel() {
+    return process.platform === 'darwin' ? 'Reveal in Finder' : 'Reveal in Explorer';
+}
+async function exportDialogProject(projectRoot) {
+    const project = (0, skein_1.readProject)(projectRoot);
+    if (project.exports.length === 0) {
+        const choice = await vscode.window.showErrorMessage('No export configurations defined yet - use "Configure Exports..." first.', 'Configure Exports...');
+        if (choice === 'Configure Exports...') {
+            await configureExports(projectRoot);
+        }
+        return;
+    }
+    const picked = await vscode.window.showQuickPick(project.exports.map((config) => ({
+        label: config.name,
+        description: `${config.format}${config.includeDebug ? ', debug' : ''} → ${config.output}`,
+        config
+    })), { placeHolder: 'Which export configuration?' });
+    if (!picked) {
+        return;
+    }
+    if (!(await (0, session_runner_1.isDialogcAvailable)(project.binDir, bundledBinDir))) {
+        throw new Error('dialogc was not found on PATH, in binDir, or bundled with this extension. Install the Dialog toolchain or set "binDir" in dialog.json.');
+    }
+    const dialogcPath = (0, skein_1.resolveCommandPath)(project.binDir, 'dialogc', bundledBinDir);
+    const result = await (0, dialog_export_1.runDialogcExport)(project, picked.config, dialogcPath);
+    if (result.ok === true) {
+        const choice = await vscode.window.showInformationMessage(`Exported "${picked.config.name}" to ${result.outputPath}.`, revealFileLabel());
+        if (choice === revealFileLabel()) {
+            vscode.commands.executeCommand('revealFileInOS', vscode.Uri.file(result.outputPath));
+        }
+    }
+    else {
+        const location = result.filePath && result.line ? ` (${result.filePath}, line ${result.line})` : '';
+        vscode.window.showErrorMessage(`Export failed${location}: ${result.message}`);
+    }
+}
+async function exportWebPage(projectRoot, assetsDir) {
+    const project = (0, skein_1.readProject)(projectRoot);
+    if (project.exports.length === 0) {
+        const choice = await vscode.window.showErrorMessage('No export configurations defined yet - use "Configure Exports..." first.', 'Configure Exports...');
+        if (choice === 'Configure Exports...') {
+            await configureExports(projectRoot);
+        }
+        return;
+    }
+    const picked = await vscode.window.showQuickPick(project.exports.map((config) => ({
+        label: config.name,
+        description: `${config.format}${config.includeDebug ? ', debug' : ''}`,
+        config
+    })), { placeHolder: 'Which export configuration builds the downloadable story file?' });
+    if (!picked) {
+        return;
+    }
+    const [dialogcOk, dgdebugOk, aambundleOk] = await Promise.all([
+        (0, session_runner_1.isDialogcAvailable)(project.binDir, bundledBinDir),
+        (0, session_runner_1.isDgdebugAvailable)(project.binDir, bundledBinDir),
+        (0, session_runner_1.isAambundleAvailable)(project.binDir, bundledBinDir)
+    ]);
+    const missing = [
+        !dialogcOk && 'dialogc',
+        !dgdebugOk && 'dgdebug',
+        !aambundleOk && 'aambundle'
+    ].filter((name) => Boolean(name));
+    if (missing.length > 0) {
+        throw new Error(`${missing.join(', ')} not found on PATH, in binDir, or bundled with this extension. Install the Dialog toolchain (and AAmachine, for aambundle) or set "binDir" in dialog.json.`);
+    }
+    const paths = {
+        dialogcPath: (0, skein_1.resolveCommandPath)(project.binDir, 'dialogc', bundledBinDir),
+        aambundlePath: (0, skein_1.resolveCommandPath)(project.binDir, 'aambundle', bundledBinDir),
+        binDir: project.binDir,
+        bundledBinDir
+    };
+    const result = await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: `Exporting "${project.name}" as a web page...` }, () => (0, dialog_web_export_1.bundleWebExport)(project, picked.config, paths, assetsDir));
+    if (result.ok === true) {
+        const choice = await vscode.window.showInformationMessage(`Exported "${project.name}" to ${result.zipPath}.`, revealFileLabel());
+        if (choice === revealFileLabel()) {
+            vscode.commands.executeCommand('revealFileInOS', vscode.Uri.file(result.zipPath));
+        }
+    }
+    else {
+        vscode.window.showErrorMessage(`Web page export failed (${result.step}): ${result.message}`);
+    }
+}
+async function confirmStopIfRunning() {
+    if (!activeSession) {
+        return true;
+    }
+    const choice = await vscode.window.showWarningMessage(`A skein session ("${activeSessionId}.skein") is already running. Stopping it discards any unsaved changes - save first if you want to keep them. Stop and continue?`, { modal: true }, 'Stop and Continue');
+    if (choice !== 'Stop and Continue') {
+        return false;
+    }
+    await stopActiveSession();
+    return true;
+}
+async function stopActiveSession() {
+    if (!activeSession) {
+        return;
+    }
+    activeSession.offChange(clearCompileErrorDiagnostics);
+    await activeSession.stop();
+    activeSession = undefined;
+    activeSessionId = undefined;
+    activeProjectRoot = undefined;
+    skeinService?.setActiveSession(undefined, undefined);
+    refreshStatusBar();
+    refreshSkeinPanel();
+}
+function setActiveSession(session, sessionId, projectRoot) {
+    activeSession = session;
+    activeSessionId = sessionId;
+    activeProjectRoot = projectRoot;
+    skeinService?.setActiveSession(session, sessionId, saveActiveSession);
+    session.onChange(clearCompileErrorDiagnostics);
+    refreshStatusBar();
+    ensureSkeinPanel();
+    refreshSkeinPanel();
+}
+async function runSessionStep(action) {
+    try {
+        await action();
+        return true;
+    }
+    catch (error) {
+        if (error instanceof skein_1.DialogCompileError) {
+            await handleCompileError(error);
+            return false;
+        }
+        throw error;
+    }
+}
+async function handleCompileError(error) {
+    vscode.window.showErrorMessage(`Dialog compile error: ${error.message}`);
+    if (!error.filePath) {
+        compileErrorDiagnostics.clear();
+        return;
+    }
+    const fullPath = path.isAbsolute(error.filePath)
+        ? error.filePath
+        : path.join(activeProjectRoot ?? '', error.filePath);
+    try {
+        const document = await vscode.workspace.openTextDocument(fullPath);
+        const editor = await vscode.window.showTextDocument(document, { preview: false });
+        const lineIndex = Math.min(Math.max(0, (error.line ?? 1) - 1), document.lineCount - 1);
+        const range = document.lineAt(lineIndex).range;
+        editor.selection = new vscode.Selection(range.start, range.start);
+        editor.revealRange(range, vscode.TextEditorRevealType.InCenter);
+        const diagnostic = new vscode.Diagnostic(range, error.message, vscode.DiagnosticSeverity.Error);
+        diagnostic.source = 'dialog';
+        compileErrorDiagnostics.set(document.uri, [diagnostic]);
+    }
+    catch (openError) {
+        console.error('Failed to open compile-error source location:', openError);
+        compileErrorDiagnostics.clear();
+    }
+}
+function ensureSkeinPanel() {
+    if (skeinPanel) {
+        skeinPanel.reveal(vscode.ViewColumn.Beside);
+        return skeinPanel;
+    }
+    skeinPanel = vscode.window.createWebviewPanel('dialogIdeSkein', panelTitle(currentSessionDisplay()), vscode.ViewColumn.Beside, { enableScripts: true, retainContextWhenHidden: true });
+    skeinPanel.webview.html = getWebviewHtml(currentSessionDisplay());
+    skeinPanel.onDidDispose(() => {
+        skeinPanel = undefined;
+        stopActiveSession().catch((error) => {
+            vscode.window.showErrorMessage(error instanceof Error ? error.message : String(error));
+        });
+    });
+    return skeinPanel;
+}
+function refreshStatusBar() {
+    if (deactivating) {
+        return;
+    }
+    if (activeSession && activeSessionId) {
+        const tree = activeSession.getTree();
+        statusBarItem.text = `$(debug-stop) Dialog Skein: ${activeSessionId}.skein (${tree.getEngine()})`;
+        statusBarItem.tooltip = `Seed ${tree.getSeed()} - click to open the Skein panel`;
+        statusBarItem.command = 'dialog-ide.openSkein';
+    }
+    else {
+        statusBarItem.text = '$(play) Dialog Skein';
+        statusBarItem.tooltip = 'No skein session running - click to run the default skein';
+        statusBarItem.command = 'dialog-ide.runDefaultSkein';
+    }
+}
+function refreshSkeinPanel() {
+    if (deactivating || !skeinPanel) {
+        return;
+    }
+    const display = currentSessionDisplay();
+    skeinPanel.title = panelTitle(display);
+    skeinPanel.webview.html = getWebviewHtml(display);
+}
+function currentSessionDisplay() {
+    if (!activeSession || !activeSessionId) {
+        return undefined;
+    }
+    const tree = activeSession.getTree();
+    return { sessionId: activeSessionId, engine: tree.getEngine(), seed: tree.getSeed() };
+}
+function panelTitle(active) {
+    return active ? `${active.sessionId}.skein` : 'Skein';
+}
+function getWebviewHtml(active) {
+    const serviceUrl = skeinService ? `http://localhost:${skeinService.getPort()}/` : undefined;
+    const body = serviceUrl
+        ? `<iframe src="${serviceUrl}"></iframe>`
+        : `<p>Skein service is not running.</p>`;
+    const nonce = createNonce();
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; script-src 'nonce-${nonce}'; frame-src http://localhost:*; child-src http://localhost:*;" />
+  <title>${panelTitle(active)}</title>
+  <style>
+    html, body { height: 100%; margin: 0; }
+    body { font-family: var(--vscode-font-family); color: var(--vscode-foreground); }
+    body:not(:has(iframe)) { padding: 1rem; }
+    iframe { display: block; width: 100%; height: 100%; border: 0; }
+  </style>
+</head>
+<body>
+  ${body}
+  <script nonce="${nonce}">
+    window.addEventListener('message', (event) => {
+      if (event.data?.type !== 'forward-keydown') return;
+      const { key, code, metaKey, ctrlKey, shiftKey, altKey } = event.data;
+      document.dispatchEvent(new KeyboardEvent('keydown', { key, code, metaKey, ctrlKey, shiftKey, altKey, bubbles: true, cancelable: true }));
+    });
+  </script>
+</body>
+</html>`;
+}
+function resolveDialogGrammarPath(context) {
+    return path.join(context.extensionPath, 'syntaxes', 'dialog.tmLanguage.json');
+}
+const SIDEBURNS_EXTENSION_ID = 'sideburns3000.dialog-language-support';
+const SIDEBURNS_WARNING_SHOWN_KEY = 'dialog-ide.sideburnsConflictWarningShown';
+function warnAboutConflictingLanguageExtension(context) {
+    if (context.globalState.get(SIDEBURNS_WARNING_SHOWN_KEY)) {
+        return;
+    }
+    if (!vscode.extensions.getExtension(SIDEBURNS_EXTENSION_ID)) {
+        return;
+    }
+    context.globalState.update(SIDEBURNS_WARNING_SHOWN_KEY, true);
+    vscode.window
+        .showWarningMessage('Dialog IDE now provides its own .dg syntax highlighting, folding, and indentation. ' +
+        'Having the separate "Dialog Language Support" extension installed too can cause ' +
+        'inconsistent highlighting and a duplicate "Compile to..." menu - consider disabling or ' +
+        'uninstalling it.', 'Show Extension')
+        .then((choice) => {
+        if (choice === 'Show Extension') {
+            vscode.commands.executeCommand('workbench.extensions.search', `@id:${SIDEBURNS_EXTENSION_ID}`);
+        }
+    });
+}
+function createNonce() {
+    return Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join('');
+}
+async function openSourceAtLine(file, line) {
+    if (!activeProjectRoot) {
+        return;
+    }
+    const fullPath = path.isAbsolute(file) ? file : path.join(activeProjectRoot, file);
+    const document = await vscode.workspace.openTextDocument(fullPath);
+    const editor = await vscode.window.showTextDocument(document, { preview: false });
+    const position = new vscode.Position(Math.max(0, line - 1), 0);
+    editor.selection = new vscode.Selection(position, position);
+    editor.revealRange(new vscode.Range(position, position), vscode.TextEditorRevealType.InCenter);
+}
+class TraceViewProvider {
+    resolveWebviewView(webviewView) {
+        webviewView.webview.options = { enableScripts: true };
+        webviewView.webview.html = getTraceWebviewHtml();
+        webviewView.webview.onDidReceiveMessage((message) => {
+            const msg = message;
+            if (msg?.type === 'openSource' && typeof msg.file === 'string' && typeof msg.line === 'number') {
+                openSourceAtLine(msg.file, msg.line).catch((error) => {
+                    vscode.window.showErrorMessage(error instanceof Error ? error.message : String(error));
+                });
+            }
+        });
+    }
+}
+function getTraceWebviewHtml() {
+    const serviceUrl = skeinService ? `http://localhost:${skeinService.getPort()}/trace` : undefined;
+    const body = serviceUrl ? `<iframe src="${serviceUrl}"></iframe>` : `<p>Skein service is not running.</p>`;
+    const nonce = createNonce();
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; script-src 'nonce-${nonce}'; frame-src http://localhost:*; child-src http://localhost:*;" />
+  <title>Trace</title>
+  <style>
+    html, body { height: 100%; margin: 0; }
+    body { font-family: var(--vscode-font-family); color: var(--vscode-foreground); }
+    body:not(:has(iframe)) { padding: 1rem; }
+    iframe { display: block; width: 100%; height: 100%; border: 0; }
+  </style>
+</head>
+<body>
+  ${body}
+  <script nonce="${nonce}">
+    const vscodeApi = acquireVsCodeApi();
+    window.addEventListener('message', (event) => {
+      if (event.data?.type === 'forward-keydown') {
+        const { key, code, metaKey, ctrlKey, shiftKey, altKey } = event.data;
+        document.dispatchEvent(new KeyboardEvent('keydown', { key, code, metaKey, ctrlKey, shiftKey, altKey, bubbles: true, cancelable: true }));
+        return;
+      }
+      vscodeApi.postMessage(event.data);
+    });
+  </script>
+</body>
+</html>`;
+}
+//# sourceMappingURL=extension.js.map