scrabble-solver 2.18.10-alpha.0 → 2.18.10-alpha.2

package/packages/dictionaries/src/lib/MemoryCache.ts

@@ -0,0 +1,40 @@
+import { type Gaddag } from '@kamilmielnik/gaddag';
+import { type Locale } from '@scrabble-solver/types';
+
+import { CACHE_STALE_THRESHOLD } from '../constants';
+import type { Cache } from '../types';
+
+export class MemoryCache implements Cache<Locale, Gaddag> {
+  private readonly cache: Partial<Record<Locale, Gaddag>> = {};
+
+  private readonly cacheTimestamps: Partial<Record<Locale, number>> = {};
+
+  public get(locale: Locale): Promise<Gaddag | undefined> {
+    return Promise.resolve(this.cache[locale]);
+  }
+
+  public getLastModifiedTimestamp(locale: Locale): number | undefined {
+    return this.cacheTimestamps[locale];
+  }
+
+  public has(locale: Locale): boolean {
+    return typeof this.cache[locale] !== 'undefined';
+  }
+
+  public isStale(locale: Locale): boolean | undefined {
+    const timestamp = this.getLastModifiedTimestamp(locale);
+
+    if (!this.has(locale) || typeof timestamp === 'undefined') {
+      return undefined;
+    }
+
+    const timeSinceModification = Math.abs(timestamp - Date.now());
+    return timeSinceModification > CACHE_STALE_THRESHOLD;
+  }
+
+  public set(locale: Locale, gaddag: Gaddag): Promise<void> {
+    this.cacheTimestamps[locale] = Date.now();
+    this.cache[locale] = gaddag;
+    return Promise.resolve();
+  }
+}

package/packages/dictionaries/src/lib/createAsyncProxy.ts

@@ -0,0 +1,18 @@
+type AsyncCallback<T> = () => Promise<T>;
+
+export const createAsyncProxy = <T>(asyncCallback: AsyncCallback<T>): AsyncCallback<T> => {
+  let promise: Promise<T> | null = null;
+
+  return async (): Promise<T> => {
+    if (promise) {
+      return promise;
+    }
+
+    try {
+      promise = asyncCallback();
+      return await promise;
+    } finally {
+      promise = null;
+    }
+  };
+};

package/packages/dictionaries/src/lib/createCacheTimestampComparator.ts

@@ -0,0 +1,25 @@
+import { type Gaddag } from '@kamilmielnik/gaddag';
+import { type Locale } from '@scrabble-solver/types';
+
+import type { Cache } from '../types';
+
+export const createCacheTimestampComparator = (locale: Locale) => {
+  return (a: Cache<Locale, Gaddag>, b: Cache<Locale, Gaddag>): number => {
+    const aTimestamp = a.getLastModifiedTimestamp(locale);
+    const bTimestamp = b.getLastModifiedTimestamp(locale);
+
+    if (aTimestamp === bTimestamp) {
+      return 0;
+    }
+
+    if (typeof aTimestamp === 'undefined') {
+      return 1;
+    }
+
+    if (typeof bTimestamp === 'undefined') {
+      return -1;
+    }
+
+    return bTimestamp - aTimestamp;
+  };
+};

package/packages/dictionaries/src/lib/downloadDictionary.ts

@@ -0,0 +1,21 @@
+import { Gaddag } from '@kamilmielnik/gaddag';
+import { logEvent } from '@scrabble-solver/logger';
+import { type Locale } from '@scrabble-solver/types';
+import { getWordList } from '@scrabble-solver/word-lists';
+
+export async function downloadDictionary(locale: Locale): Promise<Gaddag> {
+  const downloadStartedAt = performance.now();
+  const words = await getWordList(locale);
+  const buildStartedAt = performance.now();
+  const gaddag = Gaddag.fromArray(words);
+
+  logEvent({
+    type: 'build',
+    locale,
+    words: words.length,
+    download_ms: Math.round(buildStartedAt - downloadStartedAt),
+    build_ms: Math.round(performance.now() - buildStartedAt),
+  });
+
+  return gaddag;
+}

package/packages/dictionaries/src/lib/getDictionaryFilepath.ts

@@ -0,0 +1,8 @@
+import { type Locale } from '@scrabble-solver/types';
+import path from 'path';
+
+import { OUTPUT_DIRECTORY } from '../constants';
+
+export const getDictionaryFilepath = (locale: Locale, directory: string = OUTPUT_DIRECTORY): string => {
+  return path.resolve(directory, `${locale}.gaddag`);
+};

package/packages/dictionaries/src/lib/index.ts

@@ -0,0 +1,7 @@
+export { createAsyncProxy } from './createAsyncProxy';
+export { createCacheTimestampComparator } from './createCacheTimestampComparator';
+export { DiskCache } from './DiskCache';
+export { downloadDictionary } from './downloadDictionary';
+export { getDictionaryFilepath } from './getDictionaryFilepath';
+export { LayeredCache } from './LayeredCache';
+export { MemoryCache } from './MemoryCache';

package/packages/dictionaries/src/types.ts

@@ -0,0 +1,7 @@
+export interface Cache<Key extends string, Value> {
+  get(key: Key): Promise<Value | undefined>;
+  getLastModifiedTimestamp(key: Key): number | undefined;
+  has(key: Key): boolean;
+  isStale(key: Key): boolean | undefined;
+  set(key: Key, value: Value): Promise<void>;
+}

package/packages/dictionaries/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+
+  "compilerOptions": {
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "exclude": ["node_modules", "**/*.test.ts"],
+  "include": ["./src", "index.ts"]
+}

package/packages/logger/README.md

@@ -0,0 +1,21 @@
+# @scrabble-solver/logger
+
+Logger used server-side.
+
+```
+$HOME/.scrabble-solver/logs/events.txt
+```
+
+## Export to CSV
+
+```shell
+bun run --filter @scrabble-solver/logger export        # every year
+bun run --filter @scrabble-solver/logger export 2026   # one year
+```
+
+writes one file per event type and year to `$HOME/.scrabble-solver/csv/<type>-YYYY.csv`, e.g. `visit-2026.csv`.
+
+## Previous format
+
+Before August 2026 the package wrote output to `all.log` and `error.log` in the same directory.
+Those files are neither read nor written anymore and can be deleted.

package/packages/logger/build/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const OUTPUT_DIRECTORY: string;
+export declare const EVENTS_FILEPATH: string;
+export declare const CSV_DIRECTORY: string;
+export declare const IS_TEST_RUN: boolean;

package/packages/logger/build/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_TEST_RUN = exports.CSV_DIRECTORY = exports.EVENTS_FILEPATH = exports.OUTPUT_DIRECTORY = void 0;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+exports.OUTPUT_DIRECTORY = path_1.default.resolve(os_1.default.homedir(), '.scrabble-solver', 'logs');
+exports.EVENTS_FILEPATH = path_1.default.resolve(exports.OUTPUT_DIRECTORY, 'events.txt');
+exports.CSV_DIRECTORY = path_1.default.resolve(os_1.default.homedir(), '.scrabble-solver', 'csv');
+exports.IS_TEST_RUN = process.env.NODE_ENV === 'test' || typeof describe === 'function';

package/packages/logger/build/describeError.d.ts

@@ -0,0 +1,5 @@
+export interface ErrorDescription {
+    message: string;
+    stack: string | undefined;
+}
+export declare function describeError(error: unknown): ErrorDescription;

package/packages/logger/build/describeError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeError = describeError;
+function describeError(error) {
+    return { message: formatError(error), stack: error instanceof Error ? error.stack : undefined };
+}
+function formatError(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const heading = `${error.name}${formatCode(error)}: ${error.message}`.trimEnd();
+    const nested = getNestedErrors(error);
+    return nested.length === 0 ? heading : `${heading} (${nested.map(formatError).join('; ')})`;
+}
+function formatCode(error) {
+    return 'code' in error && typeof error.code === 'string' ? ` [${error.code}]` : '';
+}
+function getNestedErrors(error) {
+    if (error instanceof AggregateError) {
+        return error.errors;
+    }
+    return error.cause === undefined ? [] : [error.cause];
+}

package/packages/logger/build/events.d.ts

@@ -0,0 +1,92 @@
+export type Event = BuildEvent | DefinitionEvent | DownloadEvent | ErrorEvent | SolveEvent | VerifyEvent | VisitEvent;
+export type EventType = Event['type'];
+export type EventOf<T extends EventType> = Extract<Event, {
+    type: T;
+}>;
+export type EventValue = boolean | number | string | undefined;
+export type LoggedEvent = Event & {
+    timestamp: string;
+};
+export type Operation = 'build' | 'cache' | 'definition' | 'download' | 'solve' | 'verify' | 'visit';
+type VisitEvent = {
+    type: 'visit';
+    ip?: string;
+    ua?: string;
+    referrer?: string;
+    locale?: string;
+    game?: string;
+    url?: string;
+};
+type SolveEvent = {
+    type: 'solve';
+    ip?: string;
+    ms: number;
+    locale: string;
+    game: string;
+    tiles: number;
+    blanks: number;
+    rack: string;
+    results: number;
+};
+type VerifyEvent = {
+    type: 'verify';
+    ip?: string;
+    ms: number;
+    locale: string;
+    game: string;
+    tiles: number;
+    blanks: number;
+    valid: number;
+    invalid: number;
+};
+type DownloadEvent = {
+    type: 'download';
+    ip?: string;
+    ms: number;
+    locale: string;
+    status: number;
+    encoding: 'gzip' | 'identity';
+    bytes: number;
+};
+type DefinitionEvent = {
+    type: 'definition';
+    ip?: string;
+    ms: number;
+    locale: string;
+    words: string;
+    found: number;
+};
+type BuildEvent = {
+    type: 'build';
+    locale: string;
+    words: number;
+    download_ms: number;
+    build_ms: number;
+};
+type ErrorEvent = {
+    type: 'error';
+    level: 'error' | 'warn';
+    operation: Operation;
+    locale?: string;
+    ip?: string;
+    ua?: string;
+    message: string;
+    stack?: string;
+    input?: string;
+};
+type FieldsOf<T extends EventType> = Exclude<keyof EventOf<T>, 'type'>;
+export declare const EVENT_FIELDS: {
+    readonly visit: readonly ["ip", "ua", "referrer", "locale", "game", "url"];
+    readonly solve: readonly ["ip", "ms", "locale", "game", "tiles", "blanks", "rack", "results"];
+    readonly verify: readonly ["ip", "ms", "locale", "game", "tiles", "blanks", "valid", "invalid"];
+    readonly download: readonly ["ip", "ms", "locale", "status", "encoding", "bytes"];
+    readonly definition: readonly ["ip", "ms", "locale", "words", "found"];
+    readonly build: readonly ["locale", "words", "download_ms", "build_ms"];
+    readonly error: readonly ["level", "operation", "locale", "ip", "ua", "message", "stack", "input"];
+};
+type UnlistedFields = {
+    [T in EventType]: Exclude<FieldsOf<T>, (typeof EVENT_FIELDS)[T][number]>;
+}[EventType];
+type Assert<T extends never> = T;
+export type EveryFieldIsListed = Assert<UnlistedFields>;
+export {};

package/packages/logger/build/events.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_FIELDS = void 0;
+// Field order is the column order of the exported CSV files - append only, never reorder.
+exports.EVENT_FIELDS = {
+    visit: ['ip', 'ua', 'referrer', 'locale', 'game', 'url'],
+    solve: ['ip', 'ms', 'locale', 'game', 'tiles', 'blanks', 'rack', 'results'],
+    verify: ['ip', 'ms', 'locale', 'game', 'tiles', 'blanks', 'valid', 'invalid'],
+    download: ['ip', 'ms', 'locale', 'status', 'encoding', 'bytes'],
+    definition: ['ip', 'ms', 'locale', 'words', 'found'],
+    build: ['locale', 'words', 'download_ms', 'build_ms'],
+    error: ['level', 'operation', 'locale', 'ip', 'ua', 'message', 'stack', 'input'],
+};

package/packages/logger/build/formatCsvRow.d.ts

@@ -0,0 +1,2 @@
+import { type EventValue } from './events';
+export declare function formatCsvRow(values: EventValue[]): string;

package/packages/logger/build/formatCsvRow.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCsvRow = formatCsvRow;
+const FORMULA_PREFIX = /^[=+\-@\t\r]/;
+function formatCsvRow(values) {
+    return `${values.map(formatCsvField).join(',')}\n`;
+}
+function formatCsvField(value) {
+    if (typeof value === 'undefined') {
+        return '';
+    }
+    const text = typeof value === 'string' ? escapeFormula(value) : String(value);
+    return needsQuoting(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function escapeFormula(text) {
+    return FORMULA_PREFIX.test(text) ? `'${text}` : text;
+}
+function needsQuoting(text) {
+    return /[",\n\r]/.test(text) || text !== text.trim();
+}

package/packages/logger/build/index.d.ts

@@ -0,0 +1,5 @@
+export { CSV_DIRECTORY, EVENTS_FILEPATH, OUTPUT_DIRECTORY } from './constants';
+export { EVENT_FIELDS, type Event, type EventOf, type EventType, type EventValue, type LoggedEvent, type Operation, } from './events';
+export { formatCsvRow } from './formatCsvRow';
+export { logError } from './logError';
+export { logEvent } from './logEvent';

package/packages/logger/build/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logEvent = exports.logError = exports.formatCsvRow = exports.EVENT_FIELDS = exports.OUTPUT_DIRECTORY = exports.EVENTS_FILEPATH = exports.CSV_DIRECTORY = void 0;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "CSV_DIRECTORY", { enumerable: true, get: function () { return constants_1.CSV_DIRECTORY; } });
+Object.defineProperty(exports, "EVENTS_FILEPATH", { enumerable: true, get: function () { return constants_1.EVENTS_FILEPATH; } });
+Object.defineProperty(exports, "OUTPUT_DIRECTORY", { enumerable: true, get: function () { return constants_1.OUTPUT_DIRECTORY; } });
+var events_1 = require("./events");
+Object.defineProperty(exports, "EVENT_FIELDS", { enumerable: true, get: function () { return events_1.EVENT_FIELDS; } });
+var formatCsvRow_1 = require("./formatCsvRow");
+Object.defineProperty(exports, "formatCsvRow", { enumerable: true, get: function () { return formatCsvRow_1.formatCsvRow; } });
+var logError_1 = require("./logError");
+Object.defineProperty(exports, "logError", { enumerable: true, get: function () { return logError_1.logError; } });
+var logEvent_1 = require("./logEvent");
+Object.defineProperty(exports, "logEvent", { enumerable: true, get: function () { return logEvent_1.logEvent; } });

package/packages/logger/build/logError.d.ts

@@ -0,0 +1,4 @@
+import { type EventOf, type Operation } from './events';
+type ErrorContext = Partial<Pick<EventOf<'error'>, 'input' | 'ip' | 'level' | 'locale' | 'ua'>>;
+export declare function logError(operation: Operation, error: unknown, { level, ...context }?: ErrorContext): void;
+export {};

package/packages/logger/build/logError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logError = logError;
+const constants_1 = require("./constants");
+const describeError_1 = require("./describeError");
+const logEvent_1 = require("./logEvent");
+function logError(operation, error, { level = 'error', ...context } = {}) {
+    const description = (0, describeError_1.describeError)(error);
+    (0, logEvent_1.logEvent)({ type: 'error', level, operation, ...description, ...context });
+    if (level === 'error' && !constants_1.IS_TEST_RUN) {
+        process.stderr.write(formatStderrEntry(operation, description));
+    }
+}
+function formatStderrEntry(operation, { message, stack }) {
+    const frames = stack?.split('\n').filter((line) => line.startsWith('    at ')) ?? [];
+    return `${[`${operation}: ${message}`, ...frames].join('\n')}\n`;
+}

package/packages/logger/build/logEvent.d.ts

@@ -0,0 +1,3 @@
+import { type Event } from './events';
+export declare function logEvent(event: Event): void;
+export declare function formatEventLine(event: Event, now: Date): string;

package/packages/logger/build/logEvent.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logEvent = logEvent;
+exports.formatEventLine = formatEventLine;
+const fs_1 = __importDefault(require("fs"));
+const constants_1 = require("./constants");
+const events_1 = require("./events");
+function logEvent(event) {
+    if (constants_1.IS_TEST_RUN) {
+        return;
+    }
+    try {
+        fs_1.default.mkdirSync(constants_1.OUTPUT_DIRECTORY, { recursive: true });
+        fs_1.default.appendFileSync(constants_1.EVENTS_FILEPATH, formatEventLine(event, new Date()));
+    }
+    catch (error) {
+        process.stderr.write(`Could not append to ${constants_1.EVENTS_FILEPATH}: ${String(error)}\n`);
+    }
+}
+function formatEventLine(event, now) {
+    const line = { timestamp: formatTimestamp(now), ...event };
+    return `${JSON.stringify(line, ['timestamp', 'type', ...events_1.EVENT_FIELDS[event.type]])}\n`;
+}
+function formatTimestamp(date) {
+    return `${date.toISOString().slice(0, 19)}Z`;
+}

package/packages/logger/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@scrabble-solver/logger",
+  "version": "2.18.10-alpha.2",
+  "description": "JSON-lines event log for Scrabble Solver, with CSV export.",
+  "keywords": [
+    "logger",
+    "events",
+    "csv",
+    "scrabble"
+  ],
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kamilmielnik/scrabble-solver.git"
+  },
+  "author": {
+    "name": "Kamil Mielnik",
+    "email": "kamil@kamilmielnik.com",
+    "url": "https://kamilmielnik.com"
+  },
+  "license": "CC-BY-NC-ND-4.0",
+  "bugs": {
+    "url": "https://github.com/kamilmielnik/scrabble-solver/issues"
+  },
+  "homepage": "https://scrabble-solver.org",
+  "scripts": {
+    "build": "tsc --project . && tsc --project scripts",
+    "clean": "rimraf build/",
+    "export": "bun scripts/export-csv.ts",
+    "test": "bun test src"
+  },
+  "gitHead": "f029a11f306a01937ee99fc6365cb226b972dfed"
+}

package/packages/logger/scripts/export-csv.ts

@@ -0,0 +1,113 @@
+import { once } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { type EventType, type EventValue, type LoggedEvent, CSV_DIRECTORY, EVENT_FIELDS, formatCsvRow } from '../src';
+
+import { readEvents } from './readEvents';
+
+interface CsvFile {
+  error: Error | undefined;
+  filename: string;
+  rows: number;
+  stream: fs.WriteStream;
+}
+
+const YEAR_FORMAT = /^\d{4}$/;
+
+await exportCsv(parseYear(process.argv[2]));
+
+async function exportCsv(year: string | undefined): Promise<void> {
+  fs.mkdirSync(CSV_DIRECTORY, { recursive: true });
+  const files = new Map<string, CsvFile>();
+  let skippedLines = 0;
+
+  for await (const event of readEvents()) {
+    if (!event) {
+      skippedLines += 1;
+      continue;
+    }
+
+    const eventYear = event.timestamp.slice(0, 4);
+
+    if (year && eventYear !== year) {
+      continue;
+    }
+
+    await writeRow(getFile(files, event.type, eventYear), formatEventRow(event));
+  }
+
+  await Promise.all([...files.values()].map(closeFile));
+  printSummary(files, skippedLines);
+}
+
+function formatEventRow(event: LoggedEvent): string {
+  const values: Record<string, EventValue> = event;
+  return formatCsvRow([event.timestamp, ...EVENT_FIELDS[event.type].map((field) => values[field])]);
+}
+
+function getFile(files: Map<string, CsvFile>, type: EventType, year: string): CsvFile {
+  const filename = `${type}-${year}.csv`;
+  const openedFile = files.get(filename);
+
+  if (openedFile) {
+    return openedFile;
+  }
+
+  const file = openFile(filename, type);
+  files.set(filename, file);
+  return file;
+}
+
+function openFile(filename: string, type: EventType): CsvFile {
+  const stream = fs.createWriteStream(path.join(CSV_DIRECTORY, filename));
+  const file: CsvFile = { error: undefined, filename, rows: 0, stream };
+  stream.on('error', (error) => {
+    file.error = error;
+  });
+  stream.write(formatCsvRow(['timestamp', ...EVENT_FIELDS[type]]));
+  return file;
+}
+
+async function writeRow(file: CsvFile, row: string): Promise<void> {
+  assertWritable(file);
+  file.rows += 1;
+
+  if (!file.stream.write(row)) {
+    await once(file.stream, 'drain');
+  }
+}
+
+async function closeFile(file: CsvFile): Promise<void> {
+  assertWritable(file);
+  file.stream.end();
+  await once(file.stream, 'finish');
+}
+
+function assertWritable(file: CsvFile): void {
+  if (file.error) {
+    throw file.error;
+  }
+}
+
+function printSummary(files: Map<string, CsvFile>, skippedLines: number): void {
+  if (files.size === 0) {
+    console.log('No events to export');
+  }
+
+  for (const file of [...files.values()].sort((a, b) => a.filename.localeCompare(b.filename))) {
+    console.log(`${path.join(CSV_DIRECTORY, file.filename)}: ${file.rows} rows`);
+  }
+
+  if (skippedLines > 0) {
+    console.log(`Skipped ${skippedLines} unparseable lines`);
+  }
+}
+
+function parseYear(argument: string | undefined): string | undefined {
+  if (argument !== undefined && !YEAR_FORMAT.test(argument)) {
+    throw new Error(`Expected a YYYY year, got "${argument}"`);
+  }
+
+  return argument;
+}

package/packages/logger/scripts/readEvents.ts

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import readline from 'node:readline';
+
+import { type LoggedEvent, EVENT_FIELDS, EVENTS_FILEPATH } from '../src';
+
+export async function* readEvents(): AsyncGenerator<LoggedEvent | undefined> {
+  if (!fs.existsSync(EVENTS_FILEPATH)) {
+    throw new Error(`No events file at ${EVENTS_FILEPATH}`);
+  }
+
+  const lines = readline.createInterface({ input: fs.createReadStream(EVENTS_FILEPATH), crlfDelay: Infinity });
+
+  for await (const line of lines) {
+    yield parseEvent(line);
+  }
+}
+
+function parseEvent(line: string): LoggedEvent | undefined {
+  try {
+    const value: unknown = JSON.parse(line);
+    return isLoggedEvent(value) ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isLoggedEvent(value: unknown): value is LoggedEvent {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+
+  const { timestamp, type } = value as Partial<Record<'timestamp' | 'type', unknown>>;
+  return typeof timestamp === 'string' && typeof type === 'string' && Object.hasOwn(EVENT_FIELDS, type);
+}

package/packages/logger/scripts/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../tsconfig.json",
+
+  "compilerOptions": {
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "noEmit": true
+  },
+  "include": ["./**/*.ts"]
+}

package/packages/logger/src/constants.ts

@@ -0,0 +1,13 @@
+import os from 'os';
+import path from 'path';
+
+// bun test exposes the Jest globals to every module, so their presence marks a test run even under an inherited NODE_ENV
+declare const describe: unknown;
+
+export const OUTPUT_DIRECTORY = path.resolve(os.homedir(), '.scrabble-solver', 'logs');
+
+export const EVENTS_FILEPATH = path.resolve(OUTPUT_DIRECTORY, 'events.txt');
+
+export const CSV_DIRECTORY = path.resolve(os.homedir(), '.scrabble-solver', 'csv');
+
+export const IS_TEST_RUN = process.env.NODE_ENV === 'test' || typeof describe === 'function';