code-snake 1.0.0

package/LICENSE

@@ -0,0 +1,184 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and otherwise
+transfer the Work, where such license applies only to those patent claims
+licensable by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s) with the Work
+to which such Contribution(s) was submitted. If You institute patent litigation
+against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Work or a Contribution incorporated within the Work
+constitutes direct or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate as of the date
+such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+     (a) You must give any other recipients of the Work or Derivative Works a
+     copy of this License; and
+
+     (b) You must cause any modified files to carry prominent notices stating
+     that You changed the files; and
+
+     (c) You must retain, in the Source form of any Derivative Works that You
+     distribute, all copyright, patent, trademark, and attribution notices from
+     the Source form of the Work, excluding those notices that do not pertain to
+     any part of the Derivative Works; and
+
+     (d) If the Work includes a "NOTICE" text file as part of its distribution,
+     then any Derivative Works that You distribute must include a readable copy
+     of the attribution notices contained within such NOTICE file, excluding
+     those notices that do not pertain to any part of the Derivative Works, in
+     at least one of the following places: within a NOTICE text file distributed
+     as part of the Derivative Works; within the Source form or documentation,
+     if provided along with the Derivative Works; or, within a display generated
+     by the Derivative Works, if and wherever such third-party notices normally
+     appear. The contents of the NOTICE file are for informational purposes only
+     and do not modify the License. You may add Your own attribution notices
+     within Derivative Works that You distribute, alongside or as an addendum to
+     the NOTICE text from the Work, provided that such additional attribution
+     notices cannot be construed as modifying the License.
+
+     You may add Your own copyright statement to Your modifications and may
+     provide additional or different license terms and conditions for use,
+     reproduction, or distribution of Your modifications, or for any such
+     Derivative Works as a whole, provided Your use, reproduction, and
+     distribution of the Work otherwise complies with the conditions stated in
+     this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may have
+executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied, including, without limitation, any warranties
+or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to in
+writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any character
+arising as a result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill, work stoppage,
+computer failure or malfunction, or any and all other commercial damages or
+losses), even if such Contributor has been advised of the possibility of such
+damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations
+and/or rights consistent with this License. However, in accepting such
+obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor, and only if You agree to
+indemnify, defend, and hold each Contributor harmless for any liability incurred
+by, or claims asserted against, such Contributor by reason of your accepting any
+such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+Copyright 2026 Erdem Bircan
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,46 @@
+# code-snake
+
+Snake, played inside the program's own source code. **The code is the board.**
+
+<p align="center">
+  <img src="assets/demo.gif" alt="code-snake gameplay">
+</p>
+
+No sprites, no box-drawing characters, no pixels. When code-snake starts, it reads
+its own source file, minifies it, and lays it out as fully justified text filling
+an exact rectangle. The snake exists only as *absence*: words are pushed together
+and apart every frame so that a channel of whitespace moves through the live code.
+Eat, and the program's text makes room for you.
+
+## Code as medium
+
+Most programs treat their source as an implementation detail, the thing you look
+at only when something breaks. Here the source is the material itself: the canvas,
+the playfield, and the collision geometry are all the same bytes that implement
+them. Edit the code and the board changes, because the board *is* the code.
+
+This is not a quine. The program never reproduces itself; it consumes itself,
+reflowing its own text around the game state as you play.
+
+## Run
+
+```sh
+node snake.js
+```
+
+Requires an interactive terminal and Node.js. No dependencies.
+
+| Keys | |
+|---|---|
+| arrows / `wasd` / `hjkl` | move |
+| `p` | pause |
+| `r` | restart |
+| `q` / `Ctrl-C` | quit |
+
+### Flags
+
+| Flag | Effect |
+|---|---|
+| `--green` | paint the snake body green instead of pure whitespace |
+| `--smoke [cols rows]` | render a single frame headless and exit (testing) |
+

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "code-snake",
+  "version": "1.0.0",
+  "description": "Snake, played inside its own source code. This program does not draw a board, it becomes one; the snake is the space its words leave behind. Code as medium.",
+  "keywords": [
+    "snake",
+    "game",
+    "terminal",
+    "cli",
+    "tui",
+    "ansi",
+    "text",
+    "justification",
+    "self-referential",
+    "code-as-medium",
+    "whitespace",
+    "art"
+  ],
+  "bin": {
+    "code-snake": "snake.js"
+  },
+  "main": "snake.js",
+  "files": [
+    "snake.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/erdembircan/code-snake.git"
+  },
+  "bugs": {
+    "url": "https://github.com/erdembircan/code-snake/issues"
+  },
+  "homepage": "https://github.com/erdembircan/code-snake#readme",
+  "author": "Erdem Bircan",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=14"
+  },
+  "license-wizard": {
+    "licenseId": "Apache-2.0",
+    "tokens": {
+      "[yyyy]": "2026",
+      "[name of copyright owner]": "Erdem Bircan"
+    }
+  }
+}

package/snake.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+
+/*
+  code-snake
+  by Erdem Bircan, 2026. Apache-2.0.
+
+  Code as medium: this program does not draw a board, it becomes one.
+  Source code spends its life hidden behind the screen; here it steps
+  out in front, and the game is played in the space it leaves behind.
+  Every word carries the rules that move it, and every move rearranges
+  the words. The player and the program wander the same page. If art
+  is material made self-aware, this file qualifies on a technicality.
+*/
+
+'use strict';
+
+const fs = require('fs');
+
+const SOURCE = fs.readFileSync(__filename, 'utf8');
+const PUNCT = new Set('{}()[];,=+-*/<>!&|?:.'.split(''));
+
+function minify(src) {
+  let out = '';
+  let q = null;
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i];
+    if (q) { out += c; if (c === q && src[i - 1] !== '\\') q = null; continue; }
+    if (c === "'" || c === '"' || c === '`') { q = c; out += c; continue; }
+    if (/\s/.test(c)) {
+      while (i + 1 < src.length && /\s/.test(src[i + 1])) i++;
+      const prev = out[out.length - 1];
+      const next = src[i + 1];
+      if (prev && next && !PUNCT.has(prev) && !PUNCT.has(next)) out += ' ';
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+
+function chunk(token) {
+  const MAX = 14;
+  const parts = [];
+  let rest = token;
+  while (rest.length > MAX) {
+    let cut = -1;
+    for (let i = MAX; i >= 4; i--) if (PUNCT.has(rest[i - 1])) { cut = i; break; }
+    if (cut === -1) cut = MAX;
+    parts.push(rest.slice(0, cut));
+    rest = rest.slice(cut);
+  }
+  if (rest) parts.push(rest);
+  return parts;
+}
+
+const TOKENS = minify(SOURCE).split(/\s+/).filter(Boolean).flatMap(chunk);
+const CHAR_TOTAL = TOKENS.reduce((a, w) => a + w.length, 0);
+
+const CELL_W = 5;
+const CELL_H = 2;
+
+function wrapRows(width) {
+  let rows = 1;
+  let used = 0;
+  for (const word of TOKENS) {
+    let len = word.length;
+    while (len > width) { rows++; len -= width; }
+    const need = (used ? 1 : 0) + len;
+    if (used + need <= width) used += need;
+    else { rows++; used = len; }
+  }
+  return rows;
+}
+
+let cols = 0;
+let gw = 0;
+let gh = 0;
+let marginX = 0;
+let marginY = 0;
+
+function measure(fallbackCols, fallbackRows) {
+  const rawCols = process.stdout.columns || fallbackCols || 80;
+  const rawRows = process.stdout.rows || fallbackRows || 24;
+  const idealW = Math.round(Math.sqrt(CHAR_TOTAL * 5));
+  gw = Math.max(8, Math.floor(Math.min(idealW, rawCols) / CELL_W));
+  cols = gw * CELL_W;
+  gh = Math.max(6, Math.ceil(wrapRows(cols) / CELL_H) + 1);
+  const maxGh = Math.floor((rawRows - 1) / CELL_H);
+  if (gh > maxGh) gh = Math.max(6, maxGh);
+  marginX = Math.max(0, Math.floor((rawCols - cols) / 2));
+  marginY = Math.max(0, Math.floor((rawRows - 1 - gh * CELL_H) / 2));
+}
+
+const DIRS = { up: [0, -1], down: [0, 1], left: [-1, 0], right: [1, 0] };
+const OPPOSITE = { up: 'down', down: 'up', left: 'right', right: 'left' };
+
+let snake = [];
+let dir = 'right';
+let pending = [];
+let food = null;
+let grow = 0;
+let score = 0;
+let dead = false;
+let paused = false;
+let tickMs = 160;
+let timer = null;
+
+function reset() {
+  const cy = Math.floor(gh / 2);
+  const cx = Math.floor(gw / 2);
+  snake = [];
+  for (let i = 0; i < 4; i++) snake.push([cx - i, cy]);
+  dir = 'right';
+  pending = [];
+  grow = 0;
+  score = 0;
+  dead = false;
+  paused = false;
+  tickMs = 160;
+  placeFood();
+}
+
+function onSnake(x, y) {
+  return snake.some(([sx, sy]) => sx === x && sy === y);
+}
+
+function placeFood() {
+  let x, y;
+  do {
+    x = Math.floor(Math.random() * gw);
+    y = Math.floor(Math.random() * gh);
+  } while (onSnake(x, y));
+  food = [x, y];
+}
+
+function tick() {
+  if (dead || paused) return;
+  while (pending.length) {
+    const next = pending.shift();
+    if (next !== dir && next !== OPPOSITE[dir]) { dir = next; break; }
+  }
+  const [dx, dy] = DIRS[dir];
+  const head = [snake[0][0] + dx, snake[0][1] + dy];
+  const [hx, hy] = head;
+  if (hx < 0 || hy < 0 || hx >= gw || hy >= gh || onSnake(hx, hy)) {
+    dead = true;
+    draw();
+    return;
+  }
+  snake.unshift(head);
+  if (hx === food[0] && hy === food[1]) {
+    score++;
+    grow += 2;
+    tickMs = Math.max(70, tickMs - 5);
+    placeFood();
+  }
+  if (grow > 0) grow--; else snake.pop();
+  draw();
+}
+
+function loop() {
+  clearTimeout(timer);
+  tick();
+  timer = setTimeout(loop, tickMs);
+}
+
+let ti = 0;
+let carry = [];
+
+function nextWord() {
+  if (carry.length) return carry.shift();
+  if (ti >= TOKENS.length) return null;
+  return TOKENS[ti++];
+}
+
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+const FOOD_MARK = '\x1b[0;48;5;157m' + ' '.repeat(CELL_W) + RESET + DIM;
+
+const GREEN_BODY = process.argv.includes('--green');
+
+function bodyMark(width) {
+  if (!GREEN_BODY) return ' '.repeat(width);
+  return '\x1b[0;48;5;34m' + ' '.repeat(width) + RESET + DIM;
+}
+
+function rowMarks(y) {
+  const gy = Math.floor(y / CELL_H);
+  const marks = [];
+  for (const [sx, sy] of snake) {
+    if (sy !== gy) continue;
+    marks.push({ s: sx * CELL_W, e: sx * CELL_W + CELL_W, t: 'body' });
+  }
+  if (food && food[1] === gy) {
+    marks.push({ s: food[0] * CELL_W, e: food[0] * CELL_W + CELL_W, t: 'food' });
+  }
+  marks.sort((a, b) => a.s - b.s);
+  const merged = [];
+  for (const m of marks) {
+    const last = merged[merged.length - 1];
+    if (last && last.t === 'body' && m.t === 'body' && m.s <= last.e) last.e = m.e;
+    else merged.push({ ...m });
+  }
+  return merged;
+}
+
+function justifySeg(seg) {
+  if (seg.w <= 0) return '';
+  if (seg.words.length === 0) return ' '.repeat(seg.w);
+  const extra = seg.w - seg.used;
+  const gaps = seg.words.length - 1;
+  if (gaps === 0) return seg.words[0] + ' '.repeat(extra);
+  let out = seg.words[0];
+  let prev = 0;
+  for (let i = 1; i <= gaps; i++) {
+    const acc = Math.floor((extra * i) / gaps);
+    out += ' '.repeat(1 + acc - prev) + seg.words[i];
+    prev = acc;
+  }
+  return out;
+}
+
+function layoutRow(marks, quota) {
+  const pieces = [];
+  let pos = 0;
+  for (const m of marks) {
+    pieces.push({ seg: true, w: m.s - pos, words: [], used: 0 });
+    pieces.push({ seg: false, m });
+    pos = m.e;
+  }
+  pieces.push({ seg: true, w: cols - pos, words: [], used: 0 });
+  const segs = pieces.filter(p => p.seg && p.w > 0);
+  const rowWords = [];
+  let want = 0;
+  while (want < quota) {
+    const word = nextWord();
+    if (word === null) break;
+    rowWords.push(word);
+    want += word.length;
+  }
+  const totalW = segs.reduce((a, s) => a + s.w, 0);
+  let cumW = 0;
+  let consumed = 0;
+  let wi = 0;
+  for (const seg of segs) {
+    cumW += seg.w;
+    const target = Math.floor((want * cumW) / totalW) - consumed;
+    let got = 0;
+    while (wi < rowWords.length && got < target) {
+      const word = rowWords[wi];
+      const sep = seg.words.length ? 1 : 0;
+      if (seg.used + sep + word.length <= seg.w) {
+        seg.words.push(word);
+        seg.used += sep + word.length;
+        got += word.length;
+        wi++;
+      } else {
+        const room = seg.w - seg.used - sep;
+        if (room >= 3) {
+          seg.words.push(word.slice(0, room));
+          seg.used += sep + room;
+          got += room;
+          rowWords[wi] = word.slice(room);
+        }
+        break;
+      }
+    }
+    consumed += got;
+  }
+  if (wi < rowWords.length) carry = rowWords.slice(wi).concat(carry);
+  let line = '';
+  for (const p of pieces) {
+    if (p.seg) line += justifySeg(p);
+    else line += p.m.t === 'food' ? FOOD_MARK : bodyMark(p.m.e - p.m.s);
+  }
+  return { line, consumed };
+}
+
+function renderFrame() {
+  ti = 0;
+  carry = [];
+  const H = gh * CELL_H;
+  const marksByRow = [];
+  const freeW = [];
+  let totalFree = 0;
+  for (let y = 0; y < H; y++) {
+    const m = rowMarks(y);
+    const carved = m.reduce((a, k) => a + (k.e - k.s), 0);
+    marksByRow.push(m);
+    freeW.push(cols - carved);
+    totalFree += cols - carved;
+  }
+  const lines = [];
+  let cumFree = 0;
+  let assigned = 0;
+  for (let y = 0; y < H; y++) {
+    cumFree += freeW[y];
+    const quota = Math.floor((CHAR_TOTAL * cumFree) / totalFree) - assigned;
+    const r = layoutRow(marksByRow[y], quota);
+    assigned += r.consumed;
+    lines.push(r.line);
+  }
+  return lines;
+}
+
+function statusLine() {
+  const left = dead
+    ? `  DEAD — score ${score} — press r to restart, q to quit`
+    : paused
+      ? `  PAUSED — score ${score} — press p to resume`
+      : `  score ${score}   length ${snake.length}`;
+  const right = 'arrows/wasd move · p pause · r restart · q quit  ';
+  const pad = Math.max(1, cols - left.length - right.length);
+  return (left + ' '.repeat(pad) + right).slice(0, cols);
+}
+
+function draw() {
+  const pad = ' '.repeat(marginX);
+  const lines = renderFrame().map(l => pad + l);
+  const frame =
+    '\x1b[H' + '\n'.repeat(marginY) + DIM + lines.join('\n') + RESET +
+    '\n' + pad + '\x1b[7m' + statusLine() + RESET;
+  process.stdout.write(frame);
+}
+
+function enterScreen() {
+  process.stdout.write('\x1b[?1049h\x1b[?25l\x1b[2J\x1b[H');
+}
+
+function leaveScreen() {
+  process.stdout.write('\x1b[?25h\x1b[?1049l');
+}
+
+function quit(code) {
+  clearTimeout(timer);
+  leaveScreen();
+  if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  process.exit(code || 0);
+}
+
+const KEYMAP = {
+  '\x1b[A': 'up', '\x1b[B': 'down', '\x1b[C': 'right', '\x1b[D': 'left',
+  w: 'up', s: 'down', d: 'right', a: 'left',
+  k: 'up', j: 'down', l: 'right', h: 'left',
+};
+
+function onInput(buf) {
+  let data = buf.toString('utf8');
+  while (data.length) {
+    let key;
+    if (data.startsWith('\x1b[')) { key = data.slice(0, 3); data = data.slice(3); }
+    else { key = data[0]; data = data.slice(1); }
+    if (key === '\x03' || key === 'q') quit(0);
+    else if (key === 'p' && !dead) { paused = !paused; draw(); }
+    else if (key === 'r') { reset(); draw(); }
+    else if (KEYMAP[key] && !dead && !paused) {
+      if (pending.length < 3) pending.push(KEYMAP[key]);
+    }
+  }
+}
+
+function main() {
+  const smokeAt = process.argv.indexOf('--smoke');
+  if (smokeAt !== -1) {
+    const w = parseInt(process.argv[smokeAt + 1], 10);
+    const h = parseInt(process.argv[smokeAt + 2], 10);
+    measure(w > 0 ? w : 100, h > 0 ? h : 30);
+    reset();
+    process.stdout.write(renderFrame().join('\n') + '\n' + statusLine() + '\n');
+    return;
+  }
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    process.stderr.write('code-snake needs an interactive terminal (or run with --smoke)\n');
+    process.exit(1);
+  }
+  measure();
+  reset();
+  enterScreen();
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on('data', onInput);
+  process.stdout.on('resize', () => { measure(); reset(); process.stdout.write('\x1b[2J'); draw(); });
+  process.on('SIGTERM', () => quit(0));
+  process.on('SIGINT', () => quit(0));
+  draw();
+  timer = setTimeout(loop, tickMs);
+}
+
+main();