@opencode-cockpit/daemon 0.1.4 → 0.2.0

package/dist/modules/shell/watch/presets.js

@@ -0,0 +1,299 @@
+/**
+ * Watch rules for common tools, as data rather than parsers: `done` marks the end of a run, `fail`
+ * and `ok` say how it went. They are deliberately conservative — matching a tool's summary line,
+ * not its full output — and a caller can always pass its own rule instead. Adding a tool is a row
+ * here, and a wrong guess costs a status, never a crash.
+ */
+export const PRESETS = [
+// TypeScript and linting
+{
+  name: "tsc",
+  match: "\\btsc\\b",
+  rule: {
+    done: "Found \\d+ errors?|Watching for file changes",
+    fail: "error TS\\d+",
+    ok: "Found 0 errors"
+  }
+}, {
+  name: "eslint",
+  match: "\\beslint\\b",
+  rule: {
+    done: "\\d+ problems?|Done in |^\\s*$",
+    fail: "\\d+ problems? \\(\\d*[1-9]\\d* error",
+    ok: "0 problems"
+  }
+}, {
+  name: "biome",
+  match: "\\bbiome\\b",
+  rule: {
+    done: "Checked \\d+ file|Found \\d+ (?:error|warning)",
+    fail: "Found \\d+ errors?",
+    ok: "No fixes applied|Checked \\d+ files?"
+  }
+}, {
+  name: "prettier",
+  match: "\\bprettier\\b",
+  rule: {
+    done: "\\d+ms$",
+    fail: "\\[error\\]",
+    ok: "\\(unchanged\\)"
+  }
+}, {
+  name: "mypy",
+  match: "\\bmypy\\b",
+  rule: {
+    done: "Success: no issues|Found \\d+ errors?",
+    fail: "Found \\d+ errors?",
+    ok: "Success: no issues"
+  }
+}, {
+  name: "ruff",
+  match: "\\bruff\\b",
+  rule: {
+    done: "Found \\d+ error|All checks passed",
+    fail: "Found \\d+ errors?",
+    ok: "All checks passed"
+  }
+},
+// Test runners
+{
+  name: "vitest",
+  match: "\\bvitest\\b",
+  rule: {
+    done: "Test Files\\s+\\d|Test Files\\s+\\w",
+    fail: "Test Files.*failed",
+    ok: "Test Files.*passed"
+  }
+}, {
+  name: "jest",
+  match: "\\bjest\\b",
+  rule: {
+    done: "^Tests:\\s",
+    fail: "Tests:.*\\d+ failed",
+    ok: "Tests:.*passed"
+  }
+}, {
+  name: "mocha",
+  match: "\\bmocha\\b",
+  rule: {
+    done: "\\d+ (?:passing|failing)",
+    fail: "[1-9]\\d* failing",
+    ok: "\\d+ passing"
+  }
+}, {
+  name: "bun-test",
+  match: "bun\\s+(?:--\\S+\\s+)*test\\b",
+  rule: {
+    done: "Ran \\d+ tests?",
+    fail: "[1-9]\\d* fail",
+    ok: "\\b0 fail"
+  }
+}, {
+  name: "deno-test",
+  match: "deno\\s+test\\b",
+  rule: {
+    done: "test result:",
+    fail: "FAILED",
+    ok: "test result: ok"
+  }
+}, {
+  name: "pytest",
+  match: "\\bpytest\\b",
+  rule: {
+    done: "=+ .*(?:passed|failed|error|no tests ran).* =+",
+    fail: "\\d+ (?:failed|error)",
+    ok: "\\d+ passed"
+  }
+}, {
+  name: "rspec",
+  match: "\\brspec\\b",
+  rule: {
+    done: "\\d+ examples?, \\d+ failures?",
+    fail: "[1-9]\\d* failures?",
+    ok: " 0 failures"
+  }
+}, {
+  name: "phpunit",
+  match: "phpunit",
+  rule: {
+    done: "^OK \\(|FAILURES!|ERRORS!",
+    fail: "FAILURES!|ERRORS!",
+    ok: "^OK \\("
+  }
+}, {
+  name: "playwright",
+  match: "playwright\\s+test",
+  rule: {
+    done: "\\d+ (?:passed|failed)",
+    fail: "[1-9]\\d* failed",
+    ok: "\\d+ passed"
+  }
+}, {
+  name: "cypress",
+  match: "\\bcypress\\b",
+  rule: {
+    done: "All specs passed|\\d+ of \\d+ failed",
+    fail: "\\d+ of \\d+ failed",
+    ok: "All specs passed"
+  }
+},
+// Dev servers and bundlers
+{
+  name: "vite",
+  match: "\\bvite\\b",
+  rule: {
+    done: "ready in|page reload|hmr update|built in",
+    fail: "Internal server error|Rollup failed|error during build",
+    ok: "ready in|built in"
+  }
+}, {
+  name: "next",
+  match: "\\bnext\\s+(?:dev|build|start)",
+  rule: {
+    done: "Compiled|Ready in|Creating an optimized",
+    fail: "Failed to compile|⨯",
+    ok: "Compiled successfully|✓ Compiled|Ready in"
+  }
+}, {
+  name: "nuxt",
+  match: "\\bnuxt\\b",
+  rule: {
+    done: "Nuxt .*ready|built in|✔ (?:Client|Server)",
+    fail: "ERROR|✖",
+    ok: "ready in|built in"
+  }
+}, {
+  name: "astro",
+  match: "\\bastro\\b",
+  rule: {
+    done: "watching for file changes|Complete!|ready in",
+    fail: "error",
+    ok: "Complete!|ready in",
+    ignoreCase: true
+  }
+}, {
+  name: "angular",
+  match: "\\bng\\s+(?:serve|build|test)",
+  rule: {
+    done: "Application bundle generation complete|Compiled successfully|Build at",
+    fail: "Error:|ERROR",
+    ok: "Compiled successfully|generation complete"
+  }
+}, {
+  name: "webpack",
+  match: "\\b(?:webpack|rspack)\\b",
+  rule: {
+    done: "compiled|webpack \\d",
+    fail: "ERROR in|compiled with \\d+ error",
+    ok: "compiled successfully"
+  }
+}, {
+  name: "esbuild",
+  match: "\\besbuild\\b",
+  rule: {
+    done: "build finished|Done in",
+    fail: "✘ \\[ERROR\\]",
+    ok: "build finished"
+  }
+}, {
+  name: "tsup",
+  match: "\\btsup\\b",
+  rule: {
+    done: "Build success|⚡️ Build",
+    fail: "error",
+    ok: "Build success",
+    ignoreCase: true
+  }
+}, {
+  name: "turbo",
+  match: "\\bturbo\\b",
+  rule: {
+    done: "Tasks:\\s+\\d+ successful",
+    fail: "ERROR  run failed|Tasks:.*\\d+ failed",
+    ok: "Tasks:\\s+\\d+ successful"
+  }
+}, {
+  name: "metro",
+  match: "expo\\s+start|react-native\\s+start|\\bmetro\\b",
+  rule: {
+    done: "Bundled|BUNDLE",
+    fail: "error:|Failed building",
+    ok: "Bundled",
+    ignoreCase: true
+  }
+}, {
+  name: "storybook",
+  match: "storybook",
+  rule: {
+    done: "started|built",
+    fail: "ERR!|Error:",
+    ok: "started|built"
+  }
+},
+// Compiled languages and infrastructure
+{
+  name: "cargo",
+  match: "\\bcargo\\b",
+  rule: {
+    done: "Finished|error\\[|error:|test result:",
+    fail: "^error(?:\\[|:)|test result: FAILED",
+    ok: "Finished|test result: ok"
+  }
+}, {
+  name: "go",
+  match: "\\bgo\\s+(?:build|test|run|vet)",
+  rule: {
+    done: "^(?:ok|FAIL|PASS|\\?)\\s",
+    fail: "^FAIL|\\.go:\\d+:",
+    ok: "^ok\\s"
+  }
+}, {
+  name: "dotnet",
+  match: "\\bdotnet\\s+(?:build|watch|test|run)",
+  rule: {
+    done: "Build succeeded|Build FAILED|Passed!|Failed!",
+    fail: "Build FAILED|Failed!|error [A-Z]+\\d+",
+    ok: "Build succeeded|Passed!"
+  }
+}, {
+  name: "gradle",
+  match: "\\bgradlew?\\b",
+  rule: {
+    done: "BUILD SUCCESSFUL|BUILD FAILED",
+    fail: "BUILD FAILED",
+    ok: "BUILD SUCCESSFUL"
+  }
+}, {
+  name: "maven",
+  match: "\\bmvn\\b",
+  rule: {
+    done: "BUILD SUCCESS|BUILD FAILURE",
+    fail: "BUILD FAILURE",
+    ok: "BUILD SUCCESS"
+  }
+}, {
+  name: "docker-compose",
+  match: "docker[\\s-]compose",
+  rule: {
+    fail: "ERROR|exited with code [1-9]",
+    ok: "Started|healthy",
+    idleSeconds: 5
+  }
+}, {
+  name: "terraform",
+  match: "\\bterraform\\b",
+  rule: {
+    done: "Apply complete|Plan:|Error:",
+    fail: "Error:",
+    ok: "Apply complete|No changes"
+  }
+}];
+const byName = new Map(PRESETS.map(preset => [preset.name, preset]));
+export function presetByName(name) {
+  return byName.get(name);
+}
+
+/** First preset whose `match` fits the command, e.g. `npm run dev` → nothing, `tsc --watch` → tsc. */
+export function presetForCommand(command) {
+  return PRESETS.find(preset => preset.match && new RegExp(preset.match, "i").test(command));
+}

package/dist/modules/shell/watch/watcher.js

@@ -0,0 +1,82 @@
+export function compileRule(rule) {
+  const flags = rule.ignoreCase ? "i" : "";
+  const compiled = {};
+  if (rule.done) compiled.done = new RegExp(rule.done, flags);
+  if (rule.fail) compiled.fail = new RegExp(rule.fail, flags);
+  if (rule.ok) compiled.ok = new RegExp(rule.ok, flags);
+  if (rule.idleSeconds) compiled.idleMs = Math.round(rule.idleSeconds * 1000);
+  return compiled;
+}
+/**
+ * Tracks the health of one shell from its log.
+ *
+ * A run ends when `done` matches (or, without it, after `idleSeconds` of silence); the run's status
+ * is then `fail` if anything matched `fail`, `ok` if anything matched `ok`, and otherwise whatever
+ * it was. Only status changes are reported — a watcher that recompiles a thousand times says
+ * nothing until something actually breaks or gets fixed. A new failing line during an already
+ * failing run is reported too, since it is different news.
+ */
+export class Watcher {
+  status = "pending";
+  runs = 0;
+  since = Date.now();
+  constructor(rule, preset) {
+    this.rule = rule;
+    this.preset = preset;
+  }
+  get idleMs() {
+    return this.rule.done ? undefined : this.rule.idleMs;
+  }
+  state() {
+    const state = {
+      status: this.status,
+      runs: this.runs,
+      since: this.since
+    };
+    if (this.preset) state.preset = this.preset;
+    if (this.summaryText) state.summary = this.summaryText;
+    return state;
+  }
+
+  /** Feeds one committed log line. Returns a change when the reported status or failure changed. */
+  line(text, now = Date.now()) {
+    if (this.rule.fail?.test(text)) this.sawFail = text.trim();else if (this.rule.ok?.test(text)) this.sawOk = text.trim();
+    if (!this.rule.done?.test(text)) return undefined;
+    return this.settle(now);
+  }
+
+  /** Ends the current run because output went quiet (rules without a `done` pattern). */
+  idle(now = Date.now()) {
+    if (this.rule.done) return undefined;
+    return this.settle(now);
+  }
+
+  /** The process ended: a watched program that stops is a failure unless it exited cleanly. */
+  exited(exitCode, signal, now = Date.now()) {
+    const clean = exitCode === 0 && !signal;
+    const summary = clean ? this.summaryText : `process ended ${signal ? `on ${signal}` : `with exit code ${exitCode ?? "?"}`}`;
+    return this.apply(clean ? this.sawFail ? "fail" : this.status === "pending" ? "ok" : this.status : "fail", summary, now);
+  }
+  settle(now) {
+    if (!this.sawFail && !this.sawOk && this.status === "pending") return undefined;
+    this.runs++;
+    const status = this.sawFail ? "fail" : this.sawOk ? "ok" : this.status;
+    const summary = this.sawFail ?? this.sawOk ?? this.summaryText;
+    this.sawFail = undefined;
+    this.sawOk = undefined;
+    return this.apply(status === "pending" ? "unknown" : status, summary, now);
+  }
+  apply(status, summary, now) {
+    const changed = status !== this.status || status === "fail" && summary !== this.summaryText;
+    const previous = this.status;
+    this.status = status;
+    this.summaryText = summary;
+    if (!changed) return undefined;
+    this.since = now;
+    return {
+      previous,
+      current: status,
+      summary
+    };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-cockpit/daemon",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "cockpitd: the process host behind opencode-cockpit (PTY shells, clean logs, wait conditions)",
   "type": "module",
   "license": "MIT",
@@ -21,12 +21,19 @@
     "terminal"
   ],
   "exports": {
-    ".": "./src/index.ts",
-    "./main": "./src/main.ts",
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./main": {
+      "types": "./types/main.d.ts",
+      "default": "./dist/main.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
-    "src",
+    "dist",
+    "types",
     "README.md",
     "LICENSE"
   ],
@@ -34,7 +41,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@opencode-cockpit/protocol": "0.1.4",
+    "@opencode-cockpit/protocol": "0.2.0",
     "@xterm/headless": "6.0.0"
   },
   "engines": {

package/types/core/daemon.d.ts

@@ -0,0 +1,36 @@
+import { type CockpitPaths } from "@opencode-cockpit/protocol";
+import { type Level, type Logger } from "./logger.ts";
+import type { Module } from "./module.ts";
+export interface DaemonOptions {
+    paths: CockpitPaths;
+    modules: Module[];
+    /** Shut down after this long with no clients and no busy module. 0 disables. */
+    idleTimeoutMs?: number;
+    logLevel?: Level;
+    /** Log to the log file (default) or stderr. */
+    logToFile?: boolean;
+}
+export declare const DAEMON_VERSION: string;
+/** Build id of this daemon's own code; computed once, matches what clients compute for the entry. */
+export declare const DAEMON_BUILD: string;
+export declare class Daemon {
+    private readonly options;
+    readonly log: Logger;
+    private readonly router;
+    private readonly server;
+    private readonly startedAt;
+    private idleTimer;
+    private idleCheck;
+    private stopping;
+    private resolveStopped;
+    /** Resolves once the daemon has fully shut down. */
+    readonly stopped: Promise<void>;
+    constructor(options: DaemonOptions);
+    start(): Promise<void>;
+    stop(reason?: string): Promise<void>;
+    private busy;
+    private refreshIdle;
+    /** Refuse to start if a live daemon owns the socket; otherwise clear a stale one. */
+    private claimSocket;
+    private registerCore;
+}

package/types/core/errors.d.ts

@@ -0,0 +1,4 @@
+import { RpcError } from "@opencode-cockpit/protocol";
+export declare const notFound: (what: string) => RpcError;
+export declare const invalidState: (message: string) => RpcError;
+export declare const invalidParams: (message: string, data?: unknown) => RpcError;

package/types/core/logger.d.ts

@@ -0,0 +1,11 @@
+export type Level = "debug" | "info" | "warn" | "error";
+export interface Logger {
+    debug(msg: string, fields?: Record<string, unknown>): void;
+    info(msg: string, fields?: Record<string, unknown>): void;
+    warn(msg: string, fields?: Record<string, unknown>): void;
+    error(msg: string, fields?: Record<string, unknown>): void;
+    child(scope: string): Logger;
+}
+/** JSON-lines logger. Writes synchronously so the last lines survive a crash. */
+export declare function createLogger(file: string | undefined, level?: Level, scope?: string): Logger;
+export declare const silentLogger: Logger;

package/types/core/module.d.ts

@@ -0,0 +1,37 @@
+import type { MethodName, Methods, ParsedParamsOf, ResultOf } from "@opencode-cockpit/protocol";
+import type { Logger } from "./logger.ts";
+/** A connected client as seen by modules. */
+export interface Peer {
+    readonly id: number;
+    readonly name: string;
+    /** Send an event to this peer only, regardless of its subscriptions. */
+    send(topic: string, data: unknown): void;
+    /** Run when the peer disconnects. */
+    onClose(fn: () => void): void;
+    /** Topic patterns: exact (`shell.exited`), namespace (`shell.*`) or everything (`*`). */
+    readonly topics: Set<string>;
+    greet(name: string): void;
+}
+export interface CallContext {
+    peer: Peer;
+}
+export interface ModuleContext {
+    log: Logger;
+    /** Broadcast to every peer subscribed to `topic`. */
+    emit(topic: string, data: unknown): void;
+}
+type Handler<M extends MethodName> = (params: ParsedParamsOf<Methods, M>, call: CallContext) => Promise<ResultOf<Methods, M>> | ResultOf<Methods, M>;
+/** Handlers for the methods under one namespace, typed from the protocol contract. */
+export type MethodTable<NS extends string> = {
+    [M in MethodName as M extends `${NS}.${infer Rest}` ? Rest : never]: Handler<M>;
+};
+export interface Module<NS extends string = string> {
+    readonly name: NS;
+    /** Typed per namespace; erased to a plain record when modules are handled generically. */
+    readonly methods: string extends NS ? object : MethodTable<NS>;
+    start(ctx: ModuleContext): Promise<void>;
+    stop(): Promise<void>;
+    /** While true the daemon will not shut down for idleness. */
+    busy(): boolean;
+}
+export {};

package/types/core/router.d.ts

@@ -0,0 +1,11 @@
+import type { CallContext, Module } from "./module.ts";
+type AnyHandler = (params: unknown, call: CallContext) => unknown;
+/** Validates params against the protocol contract and dispatches to module handlers. */
+export declare class Router {
+    private readonly handlers;
+    add(name: string, handler: AnyHandler): void;
+    addModule(module: Module): void;
+    has(name: string): boolean;
+    dispatch(name: string, params: unknown, call: CallContext): Promise<unknown>;
+}
+export {};

package/types/core/server.d.ts

@@ -0,0 +1,49 @@
+import type { Socket } from "bun";
+import type { Logger } from "./logger.ts";
+import type { Peer } from "./module.ts";
+import type { Router } from "./router.ts";
+interface ConnState {
+    peer: PeerImpl;
+}
+declare class PeerImpl implements Peer {
+    readonly id: number;
+    private readonly socket;
+    private readonly log;
+    name: string;
+    greeted: boolean;
+    readonly topics: Set<string>;
+    private readonly closers;
+    private queue;
+    private queued;
+    closed: boolean;
+    constructor(id: number, socket: Socket<ConnState>, log: Logger);
+    greet(name: string): void;
+    onClose(fn: () => void): void;
+    send(topic: string, data: unknown): void;
+    subscribed(topic: string): boolean;
+    write(message: unknown): void;
+    drain(): void;
+    close(): void;
+    private enqueue;
+}
+export interface RpcServerHooks {
+    onConnect(count: number): void;
+    onDisconnect(count: number): void;
+}
+export declare class RpcServer {
+    private readonly router;
+    private readonly hooks;
+    private readonly log;
+    private listener;
+    private readonly peers;
+    private nextId;
+    constructor(router: Router, hooks: RpcServerHooks, log: Logger);
+    get clientCount(): number;
+    listen(path: string): void;
+    broadcast(topic: string, data: unknown): void;
+    stop(): void;
+    private drop;
+    private handleLine;
+    private invoke;
+}
+export type { PeerImpl };

package/{src/index.ts → types/index.d.ts}

@@ -1,5 +1,5 @@
-export { DAEMON_BUILD, DAEMON_VERSION, Daemon, type DaemonOptions } from "./core/daemon.ts"
-export type { CallContext, MethodTable, Module, ModuleContext, Peer } from "./core/module.ts"
-export { createModules, type ModuleOptions } from "./modules/index.ts"
-export { ShellModule, type ShellModuleOptions } from "./modules/shell/module.ts"
-export type { PtyBackend, PtyProcess, PtySpawnOptions } from "./modules/shell/pty.ts"
+export { DAEMON_BUILD, DAEMON_VERSION, Daemon, type DaemonOptions } from "./core/daemon.ts";
+export type { CallContext, MethodTable, Module, ModuleContext, Peer } from "./core/module.ts";
+export { createModules, type ModuleOptions } from "./modules/index.ts";
+export { ShellModule, type ShellModuleOptions } from "./modules/shell/module.ts";
+export type { PtyBackend, PtyProcess, PtySpawnOptions } from "./modules/shell/pty.ts";

package/types/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/types/modules/index.d.ts

@@ -0,0 +1,7 @@
+import type { Module } from "../core/module.ts";
+import { type ShellModuleOptions } from "./shell/module.ts";
+export interface ModuleOptions {
+    shell?: ShellModuleOptions;
+}
+/** Every capability the daemon hosts. Add new modules here. */
+export declare function createModules(options?: ModuleOptions): Module[];

package/types/modules/shell/ids.d.ts

@@ -0,0 +1 @@
+export declare function newShellId(): string;

package/types/modules/shell/methods.d.ts

@@ -0,0 +1,7 @@
+import type { MethodTable } from "../../core/module.ts";
+import type { ShellModule } from "./module.ts";
+/**
+ * The `shell.*` methods, kept apart from the module's lifecycle and bookkeeping so each file has
+ * one job: this one maps protocol calls onto the module, `module.ts` owns the shells.
+ */
+export declare function shellMethods(module: ShellModule): MethodTable<"shell">;

package/types/modules/shell/module.d.ts

@@ -0,0 +1,68 @@
+import type { ShellInfo, StartParams } from "@opencode-cockpit/protocol/shell";
+import type { MethodTable, Module, ModuleContext, Peer } from "../../core/module.ts";
+import { type PtyBackend } from "./pty.ts";
+import { Shell, type ShellLimits } from "./shell.ts";
+export interface ShellModuleOptions {
+    backend?: PtyBackend;
+    limits?: Partial<ShellLimits>;
+    /** Oldest finished shells are forgotten beyond this many. */
+    maxFinished?: number;
+    /** Base environment for spawned processes (defaults to the daemon's). */
+    baseEnv?: Record<string, string | undefined>;
+    /** Coalesce output events per attached peer for this long. */
+    outputFlushMs?: number;
+    /** Where to record owned process groups so a restarted daemon can reap orphans. */
+    registryFile?: string;
+    /** Directory for per-shell log files, when a caller asks for one. */
+    logDir?: string;
+}
+export declare class ShellModule implements Module<"shell"> {
+    private readonly options;
+    readonly name: "shell";
+    /** @internal */
+    readonly shells: Map<string, Shell>;
+    /** @internal */
+    readonly attachments: Map<string, () => void>;
+    private readonly backend;
+    private readonly limits;
+    private log;
+    private registry;
+    private readonly idleTimers;
+    /** @internal */
+    emit: ModuleContext["emit"];
+    constructor(options?: ShellModuleOptions);
+    start(ctx: ModuleContext): Promise<void>;
+    stop(): Promise<void>;
+    busy(): boolean;
+    readonly methods: MethodTable<"shell">;
+    /** @internal used by methods.ts */
+    startShell(params: StartParams): ShellInfo;
+    /** @internal used by methods.ts */
+    findReusable(params: StartParams): Shell | undefined;
+    /** @internal used by methods.ts */
+    spawn(shell: Shell): void;
+    private onExit;
+    /** @internal used by methods.ts */
+    attachStream(peer: Peer, shell: Shell): void;
+    /** @internal used by methods.ts */
+    detach(peer: Peer, id: string): void;
+    /**
+     * Rules without a `done` pattern end a run on silence, so poll those watchers; the check is a
+     * timestamp comparison, and only shells that need it are polled.
+     */
+    /** @internal used by methods.ts */
+    armIdle(shell: Shell): void;
+    /** @internal used by methods.ts */
+    clearIdle(id: string): void;
+    /** @internal used by methods.ts */
+    forget(shell: Shell): void;
+    /** @internal used by methods.ts */
+    pruneFinished(): void;
+    /** @internal used by methods.ts */
+    require(id: string): Shell;
+    /** @internal used by methods.ts */
+    uniqueId(): string;
+    /** @internal used by methods.ts */
+    environment(extra: Record<string, string> | undefined): Record<string, string>;
+}
+export declare function compilePattern(pattern: string, ignoreCase: boolean): RegExp;