canary-lab 0.1.0

package/dist/shared/e2e-runner/summary-reporter.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
+function slugify(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+class SummaryReporter {
+    results = [];
+    onTestEnd(test, result) {
+        this.results.push({
+            name: `test-case-${slugify(test.title)}`,
+            passed: result.status === 'passed',
+        });
+    }
+    onEnd(_result) {
+        const summary = {
+            total: this.results.length,
+            passed: this.results.filter((r) => r.passed).length,
+            failed: this.results.filter((r) => !r.passed).map((r) => r.name),
+        };
+        fs_1.default.mkdirSync(paths_1.LOGS_DIR, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(paths_1.LOGS_DIR, 'e2e-summary.json'), JSON.stringify(summary, null, 2) + '\n');
+    }
+}
+exports.default = SummaryReporter;

package/dist/shared/env-switcher/root-cli.d.ts

@@ -0,0 +1 @@
+export declare function main(args?: string[]): Promise<void>;

package/dist/shared/env-switcher/root-cli.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const readline_1 = __importDefault(require("readline"));
+const child_process_1 = require("child_process");
+const project_root_1 = require("../runtime/project-root");
+const FEATURES_DIR = (0, project_root_1.getFeaturesDir)();
+const SWITCH_SCRIPT = path_1.default.join(__dirname, 'switch.js');
+function prompt(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+async function selectOption(rl, label, options) {
+    console.log(`\n${label}`);
+    options.forEach((opt, i) => console.log(`  ${i + 1}) ${opt}`));
+    while (true) {
+        const answer = await prompt(rl, `Select [1-${options.length}]: `);
+        const idx = parseInt(answer.trim(), 10) - 1;
+        if (idx >= 0 && idx < options.length)
+            return options[idx];
+        console.log(`  Please enter a number between 1 and ${options.length}`);
+    }
+}
+function discoverFeaturesWithEnvSets() {
+    return fs_1.default.readdirSync(FEATURES_DIR, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name)
+        .filter(name => fs_1.default.existsSync(path_1.default.join(FEATURES_DIR, name, 'envsets', 'envsets.config.json')))
+        .sort();
+}
+function listEnvSets(featureName) {
+    const envSetsDir = path_1.default.join(FEATURES_DIR, featureName, 'envsets');
+    return fs_1.default.readdirSync(envSetsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name)
+        .sort();
+}
+async function main(args = process.argv.slice(2)) {
+    let mode = args[0];
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        if (mode !== '--apply' && mode !== '--revert') {
+            mode = await selectOption(rl, 'What do you want to do?', [
+                'Apply env set',
+                'Revert env files',
+            ]);
+            mode = mode.startsWith('Revert') ? '--revert' : '--apply';
+        }
+        const features = discoverFeaturesWithEnvSets();
+        if (features.length === 0) {
+            console.error('No features with env sets found.');
+            process.exit(1);
+        }
+        const featureName = await selectOption(rl, 'Which feature?', features);
+        if (mode === '--revert') {
+            console.log(`\nReverting env for ${featureName}...`);
+            (0, child_process_1.execFileSync)(process.execPath, [SWITCH_SCRIPT, featureName, '--revert'], { stdio: 'inherit' });
+            return;
+        }
+        const envSets = listEnvSets(featureName);
+        let chosenSet;
+        if (envSets.length === 1) {
+            chosenSet = envSets[0];
+            console.log(`\n  Using env set: ${chosenSet}`);
+        }
+        else {
+            chosenSet = await selectOption(rl, `Which env set for ${featureName}?`, envSets);
+        }
+        (0, child_process_1.execFileSync)(process.execPath, [SWITCH_SCRIPT, featureName, '--apply', chosenSet], { stdio: 'inherit' });
+    }
+    finally {
+        rl.close();
+    }
+}
+if (require.main === module) {
+    main().catch(err => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/dist/shared/env-switcher/switch.d.ts

@@ -0,0 +1 @@
+export declare function main(args?: string[]): Promise<void>;

package/dist/shared/env-switcher/switch.js

@@ -0,0 +1,249 @@
+"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.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const child_process_1 = require("child_process");
+const project_root_1 = require("../runtime/project-root");
+function resolveVars(str, appRoots) {
+    return str.replace(/\$([A-Z_]+)/g, (_, key) => appRoots[key] ?? `$${key}`);
+}
+function getEnvSetsDir(featureName) {
+    if (path.isAbsolute(featureName)) {
+        return path.join(featureName, 'envsets');
+    }
+    return path.join((0, project_root_1.getFeaturesDir)(), featureName, 'envsets');
+}
+function loadConfig(featureName) {
+    const envSetsDir = getEnvSetsDir(featureName);
+    const configPath = path.join(envSetsDir, 'envsets.config.json');
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Missing envsets config for "${featureName}" at ${configPath}`);
+    }
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    const config = JSON.parse(raw);
+    config.appRoots = {
+        CANARY_LAB_PROJECT_ROOT: (0, project_root_1.getProjectRoot)(),
+        ...config.appRoots,
+    };
+    return config;
+}
+function listEnvSets(envSetsDir) {
+    return fs
+        .readdirSync(envSetsDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+        .sort();
+}
+function getSlotFilesInSet(envSetsDir, setName, slots) {
+    const setDir = path.join(envSetsDir, setName);
+    return slots.filter((slot) => fs.existsSync(path.join(setDir, slot)));
+}
+function backup(targets, timestamp) {
+    const records = [];
+    for (const { targetPath } of targets) {
+        if (fs.existsSync(targetPath)) {
+            const backupPath = `${targetPath}.bak.${timestamp}`;
+            fs.copyFileSync(targetPath, backupPath);
+            records.push({ originalPath: targetPath, backupPath });
+        }
+    }
+    return records;
+}
+function applySet(envSetsDir, setName, targets) {
+    const setDir = path.join(envSetsDir, setName);
+    for (const { slot, targetPath } of targets) {
+        const sourcePath = path.join(setDir, slot);
+        if (fs.existsSync(sourcePath)) {
+            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+    }
+}
+function restore(records) {
+    for (const { originalPath, backupPath } of records) {
+        if (fs.existsSync(backupPath)) {
+            fs.copyFileSync(backupPath, originalPath);
+            fs.unlinkSync(backupPath);
+        }
+    }
+}
+function revert(targets) {
+    let found = 0;
+    for (const { targetPath } of targets) {
+        const dir = path.dirname(targetPath);
+        const base = path.basename(targetPath);
+        if (!fs.existsSync(dir))
+            continue;
+        const backups = fs
+            .readdirSync(dir)
+            .filter((f) => f.startsWith(`${base}.bak.`))
+            .sort()
+            .reverse(); // most recent first
+        if (backups.length > 0) {
+            const latest = path.join(dir, backups[0]);
+            fs.copyFileSync(latest, targetPath);
+            for (const b of backups)
+                fs.unlinkSync(path.join(dir, b));
+            found++;
+            console.log(`  Restored: ${targetPath}`);
+        }
+    }
+    if (found === 0) {
+        console.log('  No backup files found.');
+    }
+    else {
+        console.log(`\nRestored ${found} file(s).`);
+    }
+}
+async function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function main(args = process.argv.slice(2)) {
+    const featureName = args[0];
+    if (!featureName) {
+        console.error('Usage: switch.js <feature-name> [--apply <set>|--revert]');
+        process.exit(1);
+    }
+    const envSetsDir = getEnvSetsDir(featureName);
+    const config = loadConfig(featureName);
+    const feature = config.feature;
+    const targets = feature.slots.map((slot) => ({
+        slot,
+        targetPath: resolveVars(config.slots[slot].target, config.appRoots),
+    }));
+    // --- REVERT MODE ---
+    if (args[1] === '--revert') {
+        console.log(`\nReverting env files for "${featureName}"...\n`);
+        revert(targets);
+        return;
+    }
+    // --- APPLY MODE (no tests) ---
+    if (args[1] === '--apply') {
+        const setName = args[2];
+        if (!setName) {
+            console.error('Usage: switch.js <feature> --apply <set-name>');
+            process.exit(1);
+        }
+        const envSets = listEnvSets(envSetsDir);
+        if (!envSets.includes(setName)) {
+            console.error(`Unknown set "${setName}". Available: ${envSets.join(', ')}`);
+            process.exit(1);
+        }
+        const timestamp = Date.now();
+        console.log(`\nBacking up ${targets.length} file(s)...`);
+        backup(targets, timestamp);
+        console.log(`Applying "${setName}" env set...`);
+        applySet(envSetsDir, setName, targets);
+        console.log('Done. Run "npx canary-lab env" to revert originals when needed.\n');
+        return;
+    }
+    // --- INTERACTIVE MODE (prompt + run tests) ---
+    const envSets = listEnvSets(envSetsDir);
+    if (envSets.length === 0) {
+        console.error(`No env sets found in ${envSetsDir}`);
+        process.exit(1);
+    }
+    console.log(`\nWhich env set for ${featureName}?\n`);
+    envSets.forEach((setName, i) => {
+        const presentFiles = getSlotFilesInSet(envSetsDir, setName, feature.slots);
+        console.log(`  ${i + 1}) ${setName.padEnd(12)} — ${presentFiles.length} file(s) (${presentFiles.join(', ')})`);
+    });
+    console.log('');
+    let chosenSet;
+    while (!chosenSet) {
+        const answer = await prompt(`Enter number or name [1]: `);
+        const trimmed = answer === '' ? '1' : answer;
+        const asNumber = parseInt(trimmed, 10);
+        if (!isNaN(asNumber) && asNumber >= 1 && asNumber <= envSets.length) {
+            chosenSet = envSets[asNumber - 1];
+        }
+        else if (envSets.includes(trimmed)) {
+            chosenSet = trimmed;
+        }
+        else {
+            console.log(`  Invalid choice. Enter a number 1-${envSets.length} or a set name.`);
+        }
+    }
+    const timestamp = Date.now();
+    console.log(`\nBacking up ${targets.length} file(s)... `);
+    const backups = backup(targets, timestamp);
+    console.log('done');
+    console.log(`Applying "${chosenSet}" env set... `);
+    applySet(envSetsDir, chosenSet, targets);
+    console.log('done\n');
+    let cleanupDone = false;
+    function cleanup() {
+        if (cleanupDone)
+            return;
+        cleanupDone = true;
+        process.stdout.write('\nRestoring original files... ');
+        restore(backups);
+        console.log('done\n');
+    }
+    process.on('SIGINT', () => {
+        cleanup();
+        process.exit(130);
+    });
+    const testCwd = resolveVars(feature.testCwd, config.appRoots);
+    const [cmd, ...cmdArgs] = feature.testCommand.split(' ');
+    console.log(`Running: ${feature.testCommand}`);
+    console.log('─'.repeat(45));
+    const child = (0, child_process_1.spawn)(cmd, cmdArgs, { cwd: testCwd, stdio: 'inherit', shell: true });
+    child.on('close', (code) => {
+        console.log('─'.repeat(45));
+        cleanup();
+        process.exit(code ?? 0);
+    });
+    child.on('error', (err) => {
+        console.error(`Failed to run test command: ${err.message}`);
+        cleanup();
+        process.exit(1);
+    });
+}
+if (require.main === module) {
+    main().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/dist/shared/env-switcher/types.d.ts

@@ -0,0 +1,18 @@
+export type SlotDefinition = {
+    description: string;
+    target: string;
+};
+export type FeatureDefinition = {
+    slots: string[];
+    testCommand: string;
+    testCwd: string;
+};
+export type EnvSetsConfig = {
+    appRoots: Record<string, string>;
+    slots: Record<string, SlotDefinition>;
+    feature: FeatureDefinition;
+};
+export type BackupRecord = {
+    originalPath: string;
+    backupPath: string;
+};

package/dist/shared/env-switcher/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/launcher/iterm.d.ts

@@ -0,0 +1,2 @@
+import type { StartTab } from './startup';
+export declare function openItermTabs(tabs: StartTab[], label: string): void;

package/dist/shared/launcher/iterm.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openItermTabs = openItermTabs;
+const child_process_1 = require("child_process");
+function openItermTabs(tabs, label) {
+    const sessionDecls = tabs
+        .map((_, i) => i === 0
+        ? `set s1 to current session of current tab`
+        : `set t${i + 1} to create tab with default profile\n    set s${i + 1} to current session of t${i + 1}`)
+        .join('\n\n    ');
+    const sessionWrites = tabs
+        .map(({ dir, command }, i) => `tell s${i + 1}\n    delay 0.3\n    write text "cd ${dir} && ${command}"\n  end tell`)
+        .join('\n  ');
+    const script = `
+tell application "iTerm"
+  set w to create window with default profile
+  tell w
+    ${sessionDecls}
+  end tell
+
+  ${sessionWrites}
+
+  activate
+end tell
+`;
+    console.log(label);
+    (0, child_process_1.execFileSync)('osascript', ['-e', script], { stdio: 'inherit' });
+}

package/dist/shared/launcher/startup.d.ts

@@ -0,0 +1,9 @@
+import type { StartCommand } from './types';
+export interface StartTab {
+    dir: string;
+    command: string;
+    name: string;
+}
+export declare function resolvePath(p: string): string;
+export declare function normalizeStartCommand(command: string | StartCommand, fallbackName: string): StartCommand;
+export declare function isHealthy(url: string, timeoutMs?: number): Promise<boolean>;

package/dist/shared/launcher/startup.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePath = resolvePath;
+exports.normalizeStartCommand = normalizeStartCommand;
+exports.isHealthy = isHealthy;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const os_1 = __importDefault(require("os"));
+function resolvePath(p) {
+    return p.startsWith('~/') ? p.replace('~', os_1.default.homedir()) : p;
+}
+function normalizeStartCommand(command, fallbackName) {
+    if (typeof command === 'string') {
+        return {
+            command,
+            name: fallbackName,
+        };
+    }
+    return {
+        ...command,
+        name: command.name ?? fallbackName,
+    };
+}
+async function isHealthy(url, timeoutMs = 1500) {
+    const client = url.startsWith('https://') ? https_1.default : http_1.default;
+    return await new Promise((resolve) => {
+        const req = client.get(url, { timeout: timeoutMs }, (res) => {
+            res.resume();
+            resolve((res.statusCode ?? 0) < 500);
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+        req.on('error', () => resolve(false));
+    });
+}

package/dist/shared/launcher/terminal.d.ts

@@ -0,0 +1,2 @@
+import type { StartTab } from './startup';
+export declare function openTerminalTabs(tabs: StartTab[], label: string): void;

package/dist/shared/launcher/terminal.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openTerminalTabs = openTerminalTabs;
+const child_process_1 = require("child_process");
+function openTerminalTabs(tabs, label) {
+    // First tab: open a new window. Subsequent tabs: open tabs in the same window.
+    const commands = tabs.map(({ dir, command }, i) => {
+        if (i === 0) {
+            return `do script "cd ${dir} && ${command}"`;
+        }
+        return [
+            `tell application "System Events" to keystroke "t" using command down`,
+            `delay 0.5`,
+            `do script "cd ${dir} && ${command}" in front window`,
+        ].join('\n    ');
+    });
+    const script = `
+tell application "Terminal"
+  activate
+  ${commands.join('\n  ')}
+end tell
+`;
+    console.log(label);
+    (0, child_process_1.execFileSync)('osascript', ['-e', script], { stdio: 'inherit' });
+}

package/dist/shared/launcher/types.d.ts

@@ -0,0 +1,28 @@
+export interface RepoPrerequisite {
+    name: string;
+    localPath: string;
+    cloneUrl?: string;
+    startCommands?: Array<string | StartCommand>;
+}
+export interface HealthCheck {
+    url: string;
+    timeoutMs?: number;
+}
+export interface StartCommand {
+    command: string;
+    name?: string;
+    healthCheck?: HealthCheck;
+}
+export interface NgrokTunnel {
+    port: number;
+    subdomain: string;
+}
+export interface FeatureConfig {
+    name: string;
+    description: string;
+    envs: string[];
+    repos?: RepoPrerequisite[];
+    tunnels?: NgrokTunnel[];
+    startScript?: Record<string, string>;
+    featureDir: string;
+}

package/dist/shared/launcher/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/runtime/project-root.d.ts

@@ -0,0 +1,2 @@
+export declare function getProjectRoot(): string;
+export declare function getFeaturesDir(): string;

package/dist/shared/runtime/project-root.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectRoot = getProjectRoot;
+exports.getFeaturesDir = getFeaturesDir;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function looksLikeProjectRoot(candidate) {
+    return fs_1.default.existsSync(path_1.default.join(candidate, 'features'));
+}
+function getProjectRoot() {
+    const explicitRoot = process.env.CANARY_LAB_PROJECT_ROOT;
+    if (explicitRoot) {
+        return path_1.default.resolve(explicitRoot);
+    }
+    let current = path_1.default.resolve(process.cwd());
+    while (true) {
+        if (looksLikeProjectRoot(current)) {
+            return current;
+        }
+        const parent = path_1.default.dirname(current);
+        if (parent === current) {
+            return path_1.default.resolve(process.cwd());
+        }
+        current = parent;
+    }
+}
+function getFeaturesDir() {
+    return path_1.default.join(getProjectRoot(), 'features');
+}

package/dist/templates/project/.claude/skills/self-fixing-loop.md

@@ -0,0 +1,53 @@
+---
+name: Canary Lab Self-Fixing Loop
+description: Canonical Claude workflow for the broken Canary Lab demo. Triggered when the user says "self heal".
+type: skill
+---
+
+# Self-Fixing Loop
+
+## Trigger Phrase
+
+If the user types:
+
+```text
+self heal
+```
+
+follow this workflow.
+
+## Start State
+
+- The user should already have run `npx canary-lab run`
+- The selected feature should be `broken_todo_api`
+- The runner should still be open in watch mode
+
+## Read First
+
+- `logs/e2e-summary.json`
+- `logs/svc-*.log`
+- `features/broken_todo_api/scripts/server.js`
+
+## Rules
+
+- Fix the implementation, not the test
+- Do not “solve” the demo by changing the failing assertion
+- If running service code changed, run:
+
+```bash
+touch logs/.restart
+```
+
+- If no restart is needed, run:
+
+```bash
+touch logs/.rerun
+```
+
+## Copy-Paste Prompt
+
+```text
+Please read CLAUDE.md and .claude/skills/self-fixing-loop.md first.
+The Canary Lab runner is already in watch mode.
+Inspect logs/e2e-summary.json and the service logs, diagnose the failing broken_todo_api test, fix the implementation without changing the test, and then trigger the correct rerun signal.
+```

package/dist/templates/project/.codex/self-fixing-loop.md

@@ -0,0 +1,49 @@
+# Codex Self-Fixing Loop
+
+This is the canonical Codex workflow doc for the Canary Lab self-fixing flow.
+
+## Trigger Phrase
+
+If the user types:
+
+```text
+self heal
+```
+
+Codex should run this workflow.
+
+## Start State
+
+- The user should already have run `npx canary-lab run`
+- The selected feature should be `broken_todo_api`
+- The runner should still be open in watch mode
+
+## Read First
+
+- `logs/e2e-summary.json`
+- `logs/svc-*.log`
+- `features/broken_todo_api/scripts/server.js`
+
+## Rules
+
+- Fix the implementation, not the test
+- Do not “solve” the demo by changing the failing assertion
+- If running service code changed, run:
+
+```bash
+touch logs/.restart
+```
+
+- If no restart is needed, run:
+
+```bash
+touch logs/.rerun
+```
+
+## Copy-Paste Prompt
+
+```text
+Please read AGENTS.md and .codex/self-fixing-loop.md first.
+The Canary Lab runner is already in watch mode.
+Inspect logs/e2e-summary.json and the service logs, diagnose the failing broken_todo_api test, fix the implementation without changing the test, and then trigger the correct rerun signal.
+```