@valyrianjs/terminal 0.2.1 → 0.2.2

package/examples/docs/module-state-workbench.tsx

@@ -0,0 +1,283 @@
+import { v } from "valyrian.js";
+import { createPulse, createPulseStore } from "valyrian.js/pulses";
+import { FluxStore } from "valyrian.js/flux-store";
+import { Pane, Screen, Split, Text, mountTerminal } from "@valyrianjs/terminal";
+import type { TerminalMountOptions, TerminalSession } from "@valyrianjs/terminal";
+
+type JobStatus = "queued" | "running" | "done" | "blocked";
+type OperationAction = "dispatch" | "done" | "block" | "reset";
+
+interface Job {
+  id: string;
+  label: string;
+  owner: string;
+  status: JobStatus;
+}
+
+interface OperationEvent {
+  action: OperationAction;
+  job: string;
+  note: string;
+}
+
+interface ModuleStateWorkbenchDemo {
+  session: TerminalSession;
+  dispatchKey(key: string): string;
+  output(): string;
+  ansiOutput(): string;
+  isRunning(): boolean;
+  destroy(): void;
+}
+
+const INITIAL_JOBS: Job[] = [
+  { id: "docs", label: "Docs refresh", owner: "Mina", status: "running" },
+  { id: "release", label: "Package release", owner: "Omar", status: "queued" },
+  { id: "support", label: "Support sweep", owner: "Iris", status: "blocked" }
+];
+
+function createWorkbenchStores() {
+  const jobsStore = createPulseStore(
+    {
+      selectedIndex: 0,
+      jobs: INITIAL_JOBS.map((job) => ({ ...job }))
+    },
+    {
+      selectNext(state) {
+        state.selectedIndex = (state.selectedIndex + 1) % state.jobs.length;
+      },
+      selectPrevious(state) {
+        state.selectedIndex = (state.selectedIndex - 1 + state.jobs.length) % state.jobs.length;
+      },
+      updateSelectedStatus(state, status: JobStatus) {
+        state.jobs[state.selectedIndex].status = status;
+      },
+      reset(state) {
+        state.selectedIndex = 0;
+        state.jobs = INITIAL_JOBS.map((job) => ({ ...job }));
+      }
+    }
+  );
+
+  const [pulseRevision, setPulseRevision] = createPulse(1);
+
+  const operations = new FluxStore({
+    state: {
+      done: 0,
+      blocked: 1,
+      dispatched: 0,
+      timeline: ["Bootstrapped queue", "Loaded terminal session"] as string[],
+      lastAction: "dispatch" as OperationAction
+    },
+    mutations: {
+      SET_METRICS(state, jobs: Job[]) {
+        state.done = jobs.filter((job) => job.status === "done").length;
+        state.blocked = jobs.filter((job) => job.status === "blocked").length;
+      },
+      RECORD_EVENT(state, event: OperationEvent) {
+        state.lastAction = event.action;
+        state.dispatched += event.action === "dispatch" ? 1 : 0;
+        state.timeline.push(`${event.action}: ${event.job} — ${event.note}`);
+        state.timeline = state.timeline.slice(-5);
+      },
+      RESET(state) {
+        state.done = 0;
+        state.blocked = 1;
+        state.dispatched = 0;
+        state.lastAction = "reset";
+        state.timeline = ["reset: queue — restored baseline"];
+      }
+    },
+    actions: {
+      async dispatchSelected(store, job: Job) {
+        jobsStore.updateSelectedStatus("running");
+        store.commit("SET_METRICS", jobsStore.state.jobs);
+        store.commit("RECORD_EVENT", { action: "dispatch", job: job.label, note: "operator started work" });
+      },
+      async markDone(store, job: Job) {
+        jobsStore.updateSelectedStatus("done");
+        store.commit("SET_METRICS", jobsStore.state.jobs);
+        store.commit("RECORD_EVENT", { action: "done", job: job.label, note: "closed cleanly" });
+      },
+      async blockSelected(store, job: Job) {
+        jobsStore.updateSelectedStatus("blocked");
+        store.commit("SET_METRICS", jobsStore.state.jobs);
+        store.commit("RECORD_EVENT", { action: "block", job: job.label, note: "needs review" });
+      }
+    }
+  });
+
+  return { jobsStore, operations, pulseRevision, setPulseRevision };
+}
+
+type WorkbenchStores = ReturnType<typeof createWorkbenchStores>;
+
+const SURFACE_STYLE = { color: "#f5f5f5", background: "#111827", padding: { left: 1, right: 1 } };
+const DETAIL_STYLE = { color: "#f8fafc", background: "#172554", padding: { left: 1, right: 1 } };
+const FOOTER_STYLE = { color: "#d1d5db", background: "#1f2937" };
+const CURRENT_STYLE = { color: "#ffffff", background: "#14532d" };
+const MUTED_STYLE = { color: "#9ca3af" };
+
+function shouldRunSnapshot() {
+  return process.argv.includes("--snapshot") || process.env.VALYRIAN_TERMINAL_EXAMPLE_SNAPSHOT === "1" || !process.stdin.isTTY;
+}
+
+function selectedJob(stores: WorkbenchStores) {
+  return stores.jobsStore.state.jobs[stores.jobsStore.state.selectedIndex];
+}
+
+function resetStores(stores: WorkbenchStores) {
+  stores.jobsStore.reset();
+  stores.operations.commit("RESET");
+  stores.setPulseRevision(1);
+}
+
+function bumpRevision(stores: WorkbenchStores) {
+  stores.setPulseRevision((value) => value + 1);
+}
+
+export function App({ stores }: { stores: WorkbenchStores }) {
+  const selected = selectedJob(stores);
+  const manualVNode = v(Text, { style: MUTED_STYLE }, `Tracked jobs: ${stores.jobsStore.state.jobs.length}`);
+
+  return (
+    <Screen title="Operations Workbench">
+      <Text style={{ color: "#ffffff", background: "#0f172a" }}>Valyrian.js modules in terminal apps: state workbench</Text>
+      <Split direction="row" gap={1} sizes={["2fr", "1fr"]}>
+        <Pane style={SURFACE_STYLE}>
+          <Text>Operations Workbench</Text>
+          <Text>{`Pulse revision: ${stores.pulseRevision()}  Done jobs: ${stores.operations.state.done}  Blocked jobs: ${stores.operations.state.blocked}`}</Text>
+          <Text>{`Dispatches: ${stores.operations.state.dispatched}  Last action: ${stores.operations.state.lastAction}`}</Text>
+          {stores.jobsStore.state.jobs.map((job, index) => (
+            <Text state={index === stores.jobsStore.state.selectedIndex ? "current" : undefined} style={index === stores.jobsStore.state.selectedIndex ? undefined : MUTED_STYLE} styles={{ current: CURRENT_STYLE }}>{`${index === stores.jobsStore.state.selectedIndex ? ">" : " "} ${job.label} — ${job.owner} — ${job.status}`}</Text>
+          ))}
+        </Pane>
+        <Pane style={DETAIL_STYLE}>
+          <Text>{`Selected: ${selected.label}`}</Text>
+          <Text>{`Owner: ${selected.owner}`}</Text>
+          <Text>{`Status: ${selected.status}`}</Text>
+          {manualVNode}
+          <Text>FluxStore dispatch coordinates operation actions.</Text>
+          <Text>{`Timeline: ${stores.operations.state.timeline.slice(-3).join(" | ")}`}</Text>
+        </Pane>
+      </Split>
+      <Text style={FOOTER_STYLE}>J/K: select   Enter: dispatch   D: done   B: block   R: reset   Ctrl+C: quit</Text>
+    </Screen>
+  );
+}
+
+export function createModuleStateWorkbenchDemo(options: TerminalMountOptions = {}): ModuleStateWorkbenchDemo {
+  const stores = createWorkbenchStores();
+  resetStores(stores);
+  let running = true;
+  let session: TerminalSession;
+
+  function quit() {
+    running = false;
+    session.destroy();
+  }
+
+  function updateAfterOperation() {
+    bumpRevision(stores);
+    session.update();
+  }
+
+  function runSelected(action: "dispatchSelected" | "markDone" | "blockSelected") {
+    const job = selectedJob(stores);
+    void stores.operations.dispatch(action, job).then(updateAfterOperation);
+    updateAfterOperation();
+  }
+
+  session = mountTerminal(<App stores={stores} />, {
+    ...options,
+    cols: options.cols ?? 100,
+    rows: options.rows ?? 24,
+    keymap: {
+      ...options.keymap,
+      bindings: [
+        ...(options.keymap?.bindings || []),
+        { key: "j", command: { id: "jobs.next" }, scope: "global" },
+        { key: "J", command: { id: "jobs.next" }, scope: "global" },
+        { key: "k", command: { id: "jobs.previous" }, scope: "global" },
+        { key: "K", command: { id: "jobs.previous" }, scope: "global" },
+        { key: "ENTER", command: { id: "jobs.dispatch" }, scope: "global" },
+        { key: "d", command: { id: "jobs.done" }, scope: "global" },
+        { key: "D", command: { id: "jobs.done" }, scope: "global" },
+        { key: "b", command: { id: "jobs.block" }, scope: "global" },
+        { key: "B", command: { id: "jobs.block" }, scope: "global" },
+        { key: "r", command: { id: "jobs.reset" }, scope: "global" },
+        { key: "R", command: { id: "jobs.reset" }, scope: "global" },
+        { key: "CTRL_C", command: { id: "quit" }, scope: "global" }
+      ],
+      onCommand(command, context) {
+        if (command.id === "jobs.next") {
+          stores.jobsStore.selectNext();
+          session.update();
+          return true;
+        }
+        if (command.id === "jobs.previous") {
+          stores.jobsStore.selectPrevious();
+          session.update();
+          return true;
+        }
+        if (command.id === "jobs.dispatch") {
+          runSelected("dispatchSelected");
+          return true;
+        }
+        if (command.id === "jobs.done") {
+          runSelected("markDone");
+          return true;
+        }
+        if (command.id === "jobs.block") {
+          runSelected("blockSelected");
+          return true;
+        }
+        if (command.id === "jobs.reset") {
+          resetStores(stores);
+          session.update();
+          return true;
+        }
+        if (command.id === "quit") {
+          quit();
+          return true;
+        }
+        return options.keymap?.onCommand?.(command, context);
+      }
+    }
+  });
+
+  return {
+    session,
+    dispatchKey(key: string) {
+      return session.dispatchKey(key);
+    },
+    output() {
+      return session.output();
+    },
+    ansiOutput() {
+      return session.ansiOutput();
+    },
+    isRunning() {
+      return running;
+    },
+    destroy() {
+      running = false;
+      session.destroy();
+    }
+  };
+}
+
+if (import.meta.main) {
+  if (shouldRunSnapshot()) {
+    const demo = createModuleStateWorkbenchDemo({ runtime: "headless", cols: 100, rows: 24 });
+    demo.dispatchKey("J");
+    demo.dispatchKey("ENTER");
+    demo.dispatchKey("D");
+    demo.dispatchKey("K");
+    demo.dispatchKey("B");
+    process.stdout.write(demo.output());
+    process.stdout.write("\n");
+    demo.destroy();
+  } else {
+    createModuleStateWorkbenchDemo();
+  }
+}

package/examples/docs/module-tasks.tsx

@@ -0,0 +1,223 @@
+import { Task } from "valyrian.js/tasks";
+import { Pane, Screen, Text, mountTerminal } from "@valyrianjs/terminal";
+import type { TerminalMountOptions, TerminalSession } from "@valyrianjs/terminal";
+
+interface ModuleDemo {
+  session: TerminalSession;
+  dispatchKey(key: string): string;
+  output(): string;
+  ansiOutput(): string;
+  isRunning(): boolean;
+  destroy(): void;
+}
+
+interface TaskDemoState {
+  status: string;
+  result: string;
+  error: string;
+  currentJob: string;
+  seenStates: string[];
+  running: boolean;
+}
+
+const PANEL_STYLE = { color: "#f8fafc", background: "#111827", padding: { left: 1, right: 1 } };
+const FOOTER_STYLE = { color: "#dbeafe", background: "#1e293b" };
+
+function shouldRunSnapshot() {
+  return process.argv.includes("--snapshot") || process.env.VALYRIAN_TERMINAL_EXAMPLE_SNAPSHOT === "1" || !process.stdin.isTTY;
+}
+
+function waitForControlledAsync(signal: AbortSignal) {
+  return new Promise<void>((resolve) => {
+    const timer = setTimeout(resolve, 20);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+function syncTaskState(state: TaskDemoState, task: Task<string, string>) {
+  const snapshot = task.state;
+  state.status = snapshot.status;
+  state.result = snapshot.result ? `Result: ${snapshot.result}` : "Result: none";
+  state.error = snapshot.error instanceof Error ? `Error: ${snapshot.error.message}` : "Error: none";
+}
+
+function visibleTaskStates(states: string[]) {
+  const compact: string[] = [];
+  for (const status of states) {
+    if ((status === "cancelled" || status === "error") && compact[compact.length - 1] === "running") {
+      compact.pop();
+    }
+    if (compact[compact.length - 1] !== status) {
+      compact.push(status);
+    }
+  }
+  return compact.join(" -> ");
+}
+
+export function App({ state }: { state: TaskDemoState }) {
+  return (
+    <Screen title="Background Maintenance Runner">
+      <Text style={{ color: "#ffffff", background: "#020617" }}>Background Maintenance Runner</Text>
+      <Pane style={PANEL_STYLE}>
+        <Text>Maintenance Runner: runs local cleanup work through a Valyrian Task.</Text>
+        <Text>{`Task status: ${state.status}`}</Text>
+        <Text>{`Maintenance job: ${state.currentJob}`}</Text>
+        <Text>{state.result}</Text>
+        <Text>{state.error}</Text>
+        <Text>{`Seen states: ${visibleTaskStates(state.seenStates)}`}</Text>
+      </Pane>
+      <Text style={FOOTER_STYLE}>R: run cleanup   C: cancel scan   X: controlled fail   Z: reset   Ctrl+C: quit</Text>
+    </Screen>
+  );
+}
+
+export function createModuleTasksDemo(options: TerminalMountOptions = {}): ModuleDemo {
+  const state: TaskDemoState = {
+    status: "idle",
+    result: "Result: none",
+    error: "Error: none",
+    currentJob: "none",
+    seenStates: ["idle"],
+    running: true
+  };
+  const task = new Task<string, string>(async (label, { signal }) => {
+    if (label === "fail") {
+      throw new Error("controlled task failure");
+    }
+    if (label === "scan") {
+      await waitForControlledAsync(signal);
+      if (signal.aborted) return "Cancelled stale scan";
+    }
+    return `Completed ${label}`;
+  }, { strategy: "restartable" });
+  const rememberState = () => {
+    const status = task.state.status;
+    if (state.seenStates[state.seenStates.length - 1] !== status) {
+      state.seenStates.push(status);
+    }
+    syncTaskState(state, task);
+  };
+  const offTaskState = task.on("state", () => {
+    rememberState();
+    session?.update();
+  });
+  let session: TerminalSession;
+
+  function quit() {
+    state.running = false;
+    offTaskState();
+    task.reset();
+    session.destroy();
+  }
+
+  async function runTask(label: string, job: string) {
+    state.currentJob = job;
+    try {
+      rememberState();
+      await task.run(label);
+    } catch {
+      // The task state snapshot carries the controlled error message.
+    }
+    syncTaskState(state, task);
+    session.update();
+  }
+
+  session = mountTerminal(<App state={state} />, {
+    ...options,
+    cols: options.cols ?? 92,
+    rows: options.rows ?? 16,
+    keymap: {
+      ...options.keymap,
+      bindings: [
+        ...(options.keymap?.bindings || []),
+        { key: "r", command: { id: "task.run" }, scope: "global" },
+        { key: "R", command: { id: "task.run" }, scope: "global" },
+        { key: "c", command: { id: "task.cancel" }, scope: "global" },
+        { key: "C", command: { id: "task.cancel" }, scope: "global" },
+        { key: "x", command: { id: "task.error" }, scope: "global" },
+        { key: "X", command: { id: "task.error" }, scope: "global" },
+        { key: "z", command: { id: "task.reset" }, scope: "global" },
+        { key: "Z", command: { id: "task.reset" }, scope: "global" },
+        { key: "CTRL_C", command: { id: "quit" }, scope: "global" }
+      ],
+      onCommand(command, context) {
+        if (command.id === "task.run") {
+          void runTask("cleanup", "nightly cleanup");
+          return true;
+        }
+        if (command.id === "task.cancel") {
+          state.currentJob = "stale scan";
+          void task.run("scan");
+          rememberState();
+          task.cancel();
+          rememberState();
+          session.update();
+          return true;
+        }
+        if (command.id === "task.error") {
+          void runTask("fail", "permission audit");
+          return true;
+        }
+        if (command.id === "task.reset") {
+          state.currentJob = "none";
+          task.reset();
+          rememberState();
+          session.update();
+          return true;
+        }
+        if (command.id === "quit") {
+          quit();
+          return true;
+        }
+        return options.keymap?.onCommand?.(command, context);
+      }
+    }
+  });
+
+  return {
+    session,
+    dispatchKey(key: string) {
+      return session.dispatchKey(key);
+    },
+    output() {
+      return session.output();
+    },
+    ansiOutput() {
+      return session.ansiOutput();
+    },
+    isRunning() {
+      return state.running;
+    },
+    destroy() {
+      state.running = false;
+      offTaskState();
+      task.reset();
+      session.destroy();
+    }
+  };
+}
+
+if (import.meta.main) {
+  if (shouldRunSnapshot()) {
+    const demo = createModuleTasksDemo({ runtime: "headless", cols: 92, rows: 16 });
+    demo.dispatchKey("R");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    demo.dispatchKey("C");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    demo.dispatchKey("X");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    demo.dispatchKey("Z");
+    process.stdout.write(demo.output());
+    process.stdout.write("\n");
+    demo.destroy();
+  } else {
+    createModuleTasksDemo();
+  }
+}

package/examples/docs/module-translate.tsx

@@ -0,0 +1,194 @@
+import { getLang, setLang, setLog, setStoreStrategy, setTranslations, t } from "valyrian.js/translate";
+import { Pane, Screen, Text, mountTerminal } from "@valyrianjs/terminal";
+import type { TerminalMountOptions, TerminalSession } from "@valyrianjs/terminal";
+
+interface ModuleDemo {
+  session: TerminalSession;
+  dispatchKey(key: string): string;
+  output(): string;
+  ansiOutput(): string;
+  isRunning(): boolean;
+  destroy(): void;
+}
+
+type Ticket = { id: string; customer: string; status: "open" | "waiting" | "closed" };
+type SupportState = { selected: number; language: "en" | "es"; filter: "all" | "open" };
+
+const TICKETS: Ticket[] = [
+  { id: "T-104", customer: "Northwind", status: "open" },
+  { id: "T-118", customer: "Contoso", status: "waiting" },
+  { id: "T-130", customer: "Tailspin", status: "closed" }
+];
+const PANEL_STYLE = { color: "#f8fafc", background: "#111827", padding: { left: 1, right: 1 } };
+const FOOTER_STYLE = { color: "#dbeafe", background: "#1e293b" };
+let storedLanguage = "en";
+
+function configureTranslations() {
+  setLog(false);
+  setStoreStrategy({
+    get: () => storedLanguage,
+    set: (language) => {
+      storedLanguage = language;
+    }
+  });
+  setTranslations(
+    {
+      title: "Bilingual Support Console",
+      purpose: "Support Console",
+      language: "Language",
+      filter: "Filter",
+      selected: "Selected ticket",
+      all: "all tickets",
+      openOnly: "open only",
+      status: { open: "open", waiting: "waiting", closed: "closed" },
+      help: "L language   J/K select ticket   F filter status   Ctrl+C: quit"
+    },
+    {
+      es: {
+        title: "Bilingual Support Console",
+        purpose: "Consola de soporte",
+        language: "Idioma",
+        filter: "Filtro",
+        selected: "Ticket elegido",
+        all: "todos los tickets",
+        openOnly: "solo abiertos",
+        status: { open: "abierto", waiting: "en espera", closed: "cerrado" },
+        help: "L idioma   J/K elegir ticket   F filtrar estado   Ctrl+C: quit"
+      }
+    }
+  );
+}
+
+function shouldRunSnapshot() {
+  return process.argv.includes("--snapshot") || process.env.VALYRIAN_TERMINAL_EXAMPLE_SNAPSHOT === "1" || !process.stdin.isTTY;
+}
+
+function visibleTickets(filter: SupportState["filter"]) {
+  return filter === "open" ? TICKETS.filter((ticket) => ticket.status === "open") : TICKETS;
+}
+
+export function App({ state }: { state: SupportState }) {
+  setLang(state.language);
+  const tickets = visibleTickets(state.filter);
+  const selected = tickets[state.selected] || tickets[0];
+
+  return (
+    <Screen title="Bilingual Support Console">
+      <Text style={{ color: "#ffffff", background: "#020617" }}>{t("title")}</Text>
+      <Pane style={PANEL_STYLE}>
+        <Text>{t("purpose")}</Text>
+        <Text>{`${t("language")}: ${state.language === "en" ? "English" : "Español"}`}</Text>
+        <Text>{`${t("filter")}: ${state.filter === "open" ? t("openOnly") : t("all")}`}</Text>
+        {tickets.map((ticket, index) => (
+          <Text>{`${index === state.selected ? ">" : " "} ${ticket.id} ${ticket.customer} — ${t(`status.${ticket.status}`)}`}</Text>
+        ))}
+        <Text>{`${t("selected")}: ${selected.id} ${selected.customer}`}</Text>
+      </Pane>
+      <Text style={FOOTER_STYLE}>{t("help")}</Text>
+    </Screen>
+  );
+}
+
+export function createModuleTranslateDemo(options: TerminalMountOptions = {}): ModuleDemo {
+  const previousLanguage = getLang();
+  configureTranslations();
+  const state: SupportState = { selected: 0, language: "en", filter: "all" };
+  setLang(state.language);
+  let running = true;
+  let session: TerminalSession;
+
+  function quit() {
+    running = false;
+    setLang(previousLanguage);
+    session.destroy();
+  }
+
+  function clampSelection() {
+    const count = visibleTickets(state.filter).length;
+    state.selected = Math.min(state.selected, Math.max(0, count - 1));
+  }
+
+  function move(delta: number) {
+    const count = visibleTickets(state.filter).length;
+    state.selected = (state.selected + delta + count) % count;
+  }
+
+  session = mountTerminal(<App state={state} />, {
+    ...options,
+    cols: options.cols ?? 92,
+    rows: options.rows ?? 18,
+    keymap: {
+      ...options.keymap,
+      bindings: [
+        ...(options.keymap?.bindings || []),
+        { key: "l", command: { id: "support.language" }, scope: "global" },
+        { key: "L", command: { id: "support.language" }, scope: "global" },
+        { key: "j", command: { id: "support.next" }, scope: "global" },
+        { key: "J", command: { id: "support.next" }, scope: "global" },
+        { key: "k", command: { id: "support.previous" }, scope: "global" },
+        { key: "K", command: { id: "support.previous" }, scope: "global" },
+        { key: "f", command: { id: "support.filter" }, scope: "global" },
+        { key: "F", command: { id: "support.filter" }, scope: "global" },
+        { key: "CTRL_C", command: { id: "quit" }, scope: "global" }
+      ],
+      onCommand(command, context) {
+        if (command.id === "support.language") {
+          state.language = state.language === "en" ? "es" : "en";
+          setLang(state.language);
+          session.update();
+          return true;
+        }
+        if (command.id === "support.next") {
+          move(1);
+          return true;
+        }
+        if (command.id === "support.previous") {
+          move(-1);
+          return true;
+        }
+        if (command.id === "support.filter") {
+          state.filter = state.filter === "all" ? "open" : "all";
+          clampSelection();
+          return true;
+        }
+        if (command.id === "quit") {
+          quit();
+          return true;
+        }
+        return options.keymap?.onCommand?.(command, context);
+      }
+    }
+  });
+
+  return {
+    session,
+    dispatchKey(key: string) {
+      return session.dispatchKey(key);
+    },
+    output() {
+      return session.output();
+    },
+    ansiOutput() {
+      return session.ansiOutput();
+    },
+    isRunning() {
+      return running;
+    },
+    destroy() {
+      running = false;
+      setLang(previousLanguage);
+      session.destroy();
+    }
+  };
+}
+
+if (import.meta.main) {
+  if (shouldRunSnapshot()) {
+    const demo = createModuleTranslateDemo({ runtime: "headless", cols: 92, rows: 18 });
+    process.stdout.write(demo.output());
+    process.stdout.write("\n");
+    demo.destroy();
+  } else {
+    createModuleTranslateDemo();
+  }
+}