@bitcobblers/wod-wiki-tools 0.0.0-stage → 0.36.2134

package/dist/index.d.ts

@@ -0,0 +1,356 @@
+import { WodWikiIRFile, StatementNode, ExecutionLog, LanguagePack } from '@bitcobblers/wod-wiki-engine';
+import { INowProvider, IEffort } from '@bitcobblers/wod-wiki-lang';
+import { QueryServiceStores, QueryResult, RowsQueryResult, FindQueryResult, PipelineResult } from '@bitcobblers/wod-wiki-wql';
+import { EventRecord, AnalyticsDataPoint, Session, Note, BlockIndexRow, BlockRevision } from '@bitcobblers/wod-wiki-core';
+import { IStorage } from '@bitcobblers/wod-wiki-storage';
+import { Database } from '@bitcobblers/wod-wiki-storage/sql';
+
+/**
+ * Headless Parse Command Runner
+ *
+ * Parses Whiteboard Script source text and emits a versioned IR parse-tree envelope.
+ */
+
+declare class ParseSyntaxError extends Error {
+    readonly errors: Array<{
+        message: string;
+        line?: number;
+    }>;
+    constructor(errors: Array<{
+        message: string;
+        line?: number;
+    }>, message?: string);
+}
+interface ParseOptions {
+    sport?: string;
+    sourceLabel?: string;
+}
+/**
+ * Parses Whiteboard Script source directly into a StatementNode IR envelope.
+ */
+declare function runParse(source: string, options?: ParseOptions): WodWikiIRFile<StatementNode>;
+
+/**
+ * Headless Execution Command Runner
+ *
+ * Executes Whiteboard Script through JIT compiler and runtime state machine,
+ * emitting a versioned execution-log IR envelope.
+ */
+
+interface RunOptions {
+    sport?: string;
+    dialect?: 'time' | 'log';
+    blockId?: string;
+    blockVersion?: number;
+    startTime?: number;
+    maxIterations?: number;
+    now?: INowProvider;
+    sourceLabel?: string;
+}
+/**
+ * Runs a workout script to completion using headless state machine and Node clock.
+ */
+declare function runExecution(source: string, options?: RunOptions): Promise<WodWikiIRFile<ExecutionLog>>;
+
+/**
+ * Headless WQL Query Command Runner
+ *
+ * Evaluates WQL queries against in-memory stores sourced from --corpus,
+ * --stdin-log, or --stdin-facts, and emits a versioned IR envelope.
+ */
+
+declare class WqlSyntaxError extends Error {
+    readonly query: string;
+    readonly syntaxError: string;
+    constructor(query: string, syntaxError: string);
+}
+interface QueryCliOptions {
+    corpusPath?: string;
+    stdinLog?: string;
+    stdinFacts?: string;
+    preferredUnit?: string;
+    sourceLabel?: string;
+    /** Pre-built store bundle (e.g. sqlite-backed). When set, the corpus/stdin
+     *  dataset options are ignored. */
+    stores?: QueryServiceStores;
+}
+interface LoadedData {
+    eventRecords: EventRecord[];
+    facts: AnalyticsDataPoint[];
+    results: Session[];
+    notes: Note[];
+    blocks: BlockIndexRow[];
+    revisions: BlockRevision[];
+    efforts: IEffort[];
+    noteTags: Record<string, string[]>;
+}
+declare function loadQueryData(options: QueryCliOptions): LoadedData;
+/**
+ * Runs a WQL query against the provided in-memory dataset and returns a versioned IR envelope.
+ */
+declare function runQueryCli(wqlString: string, options?: QueryCliOptions): Promise<WodWikiIRFile<QueryResult | RowsQueryResult | FindQueryResult | PipelineResult>>;
+
+/**
+ * Dynamic Language Pack Loader
+ *
+ * Dynamically loads and registers Language Packs passed via `--pack <module-spec>`.
+ * Throws PackLoadError on failure, enabling exit code 3 handling.
+ */
+
+declare class PackLoadError extends Error {
+    readonly spec: string;
+    readonly originalError: unknown;
+    constructor(spec: string, originalError: unknown);
+}
+/**
+ * Dynamically imports a Language Pack module and registers it.
+ *
+ * @param moduleSpec - Relative or absolute path, or package name.
+ */
+declare function loadLanguagePack(moduleSpec: string): Promise<LanguagePack>;
+
+/**
+ * CLI Output Formatters (JSON, ASCII Table, CSV)
+ *
+ * Implements presentation formatting for parse-tree, execution-log,
+ * and WQL query results across json, table, and csv formats.
+ */
+
+type OutputFormat = 'json' | 'table' | 'csv';
+/**
+ * Format StatementNode parse tree
+ */
+declare function formatParseOutput(ir: WodWikiIRFile<StatementNode>, format: OutputFormat, pretty?: boolean): string;
+/**
+ * Format ExecutionLog runtime output
+ */
+declare function formatExecutionOutput(ir: WodWikiIRFile<ExecutionLog>, format: OutputFormat, pretty?: boolean): string;
+/**
+ * Format QueryResult / RowsQueryResult / FindQueryResult / PipelineResult
+ */
+declare function formatQueryOutput(ir: WodWikiIRFile<QueryResult | RowsQueryResult | FindQueryResult | PipelineResult>, format: OutputFormat, pretty?: boolean): string;
+
+/**
+ * Unified `wod` CLI Runner
+ *
+ * Implements CLI command routing, argument parsing, pipe handling,
+ * and exit code conventions per wayfinder #962 and issue #967.
+ *
+ * Exit Codes:
+ *   0 - OK / Success (including empty query results)
+ *   1 - Runtime error (file missing, bad arguments, execution error)
+ *   2 - Parse / Syntax error (invalid Whiteboard Script or malformed WQL)
+ *   3 - Pack load error (failed to import or register --pack)
+ */
+
+interface CliParsedArgs {
+    subcommand?: 'parse' | 'run' | 'query' | 'download' | 'import' | 'build' | 'seed' | 'reset' | 'init' | 'server' | 'serve' | 'playground' | 'help' | 'version';
+    target?: string;
+    /** Second positional: the id (download) or file (import) after the kind. */
+    target2?: string;
+    corpus?: string;
+    stdinLog?: boolean;
+    stdinFacts?: boolean;
+    format: OutputFormat;
+    output?: string;
+    packs: string[];
+    sport?: string;
+    unit?: string;
+    help?: boolean;
+    version?: boolean;
+    /** SQLite database path (--db). Defaults to WOD_WIKI_DB or ./wodwiki.db. */
+    db?: string;
+    /** Backend driver override (--db-driver): sqlite | postgres | turso. */
+    dbDriver?: string;
+    /** PostgreSQL connection URL (--database-url) or component flags below. */
+    databaseUrl?: string;
+    postgresHost?: string;
+    postgresPort?: string;
+    postgresUser?: string;
+    postgresPassword?: string;
+    postgresDatabase?: string;
+    postgresSsl?: string;
+    /** Turso/libSQL target (--turso-url) plus its auth token. */
+    tursoUrl?: string;
+    tursoAuthToken?: string;
+    /** Explicit environment file (--env-file); a missing file is an error. */
+    envFile?: string;
+    /** Hosting bind address/port and prebuilt frontend directory (server/playground). */
+    host?: string;
+    port?: string;
+    dist?: string;
+    /** IR debug output: undefined = off, '' = default file name, otherwise the file name. */
+    debug?: string;
+    /** Extra seed source directories for `wod seed` (repeatable). */
+    sources: string[];
+    /** `wod build`: scaffold markdown stubs for newly discovered efforts. */
+    scaffold?: boolean;
+    /** `wod build`: extra template markdown file compiled as the `template` chunk. */
+    template?: string;
+    /** `wod build`: content repo root (alias for the positional directory). */
+    dir?: string;
+}
+declare function parseCliArgs(args: string[]): CliParsedArgs;
+declare function readStdin(): Promise<string>;
+/**
+ * Main CLI entry point. Returns numeric exit code.
+ */
+declare function cliMain(argv?: string[], io?: {
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+    readStdinFn?: () => Promise<string>;
+}): Promise<number>;
+
+/**
+ * Database configuration for the `wod` CLI (and the dev server): explicit
+ * per-property flags → process env → .env file (native node:util.parseEnv,
+ * non-mutating).
+ *
+ * Precedence: flags beat env beats .env. `--db` selects local SQLite even
+ * when env configures a remote backend; explicit `--db-driver` /
+ * `--postgres-*` / `--turso-*` flags select that backend. Conflicting
+ * explicit selectors and ambiguous env backends are rejected. Labels and
+ * error messages never contain credentials.
+ */
+/** Optional per-property flag bag — every property unset unless given. */
+interface CliDatabaseOptions {
+    /** --db: explicit SQLite file. Selects sqlite even when env has a remote backend. */
+    db?: string;
+    /** --db-driver: sqlite | postgres | turso. */
+    dbDriver?: string;
+    /** --database-url: driver-scoped URL (mirrors DATABASE_URL). */
+    databaseUrl?: string;
+    postgresHost?: string;
+    postgresPort?: string;
+    postgresUser?: string;
+    postgresPassword?: string;
+    postgresDatabase?: string;
+    /** --postgres-ssl <mode>: true/false or disable | prefer | require | verify-ca | verify-full. */
+    postgresSsl?: string | boolean;
+    tursoUrl?: string;
+    tursoAuthToken?: string;
+    /** --env-file: explicit file is mandatory — a missing file is an error. */
+    envFile?: string;
+}
+/** Discriminated backend selection. `label` is credential-free and safe to
+ * print on every variant. sqlite is pure-local (absolute `path`); every
+ * remote libsql target normalizes to turso. */
+type PostgresSslMode = 'disable' | 'prefer' | 'require' | 'verify-ca' | 'verify-full';
+type CliDatabaseConfig = {
+    kind: 'sqlite';
+    label: string;
+    path: string;
+} | {
+    kind: 'postgres';
+    label: string;
+    url: string;
+    host: string;
+    port: number;
+    database: string;
+    user?: string;
+    password?: string;
+    ssl: PostgresSslMode;
+} | {
+    kind: 'turso';
+    label: string;
+    url: string;
+    authToken?: string;
+};
+/**
+ * Load a NON-MUTATING env object from the dotenv tier ONLY: an explicit
+ * --env-file is mandatory when given (missing file → error); otherwise
+ * `.env` in the working directory, falling back to the nearest ancestor
+ * (workspace root) `.env`. Callers merge over process.env themselves
+ * ({ ...loadCliEnvironment(file), ...process.env }); process.env is never
+ * written.
+ */
+declare function loadCliEnvironment(envFile?: string): Record<string, string | undefined>;
+/**
+ * Resolve the effective database configuration: flags > env > .env. Pass
+ * `env` to supply an already-merged tier (nothing is re-read); without it
+ * the .env tier (loadCliEnvironment) sits under the true process tier.
+ * Kind-pinning flags (--db, --db-driver, --turso-url/--turso-auth-token,
+ * --postgres-*) override even a malformed env driver; conflicting pins and
+ * ambiguous env backends are rejected. Never echoes credentials.
+ */
+declare function resolveDatabaseConfig(options?: CliDatabaseOptions, env?: Record<string, string | undefined>): CliDatabaseConfig;
+
+/**
+ * Local SQLite seam for the `wod` CLI.
+ *
+ * Opens a libsql `file:` database, initializes the shared storage schema
+ * (KV store tables + domain projections), and adapts the rows into the WQL
+ * store interfaces — the same shape the playground builds over IndexedDB.
+ *
+ * Everything heavy is loaded lazily (`@libsql/client`,
+ * `@bitcobblers/wod-wiki-storage/sql`, node `fs`/`crypto`) so browser
+ * bundles that import the engine index never pull native drivers; the
+ * dynamic specifiers stay external in the CLI bundle.
+ */
+
+interface CliDb {
+    db: Database;
+    storage: IStorage;
+    /** Absolute path of the underlying .sqlite file — or the sanitized display
+     * label (URL without credentials) for remote backends. */
+    path: string;
+    close(): Promise<void>;
+}
+/**
+ * Open the CLI database: a legacy local sqlite path (internal callers,
+ * created/initialized as before) or a resolved backend config from ./config.
+ *
+ * opts.initialize (default true): run the schema + projection
+ * initialization. false → verify the schema/projection guards only: a
+ * missing local sqlite file is NOT created and yields an actionable
+ * `wod init` error; remote targets are only probed, never created.
+ *
+ * opts.create (explicit init requests only, postgres): when the configured
+ * PostgreSQL database is missing, openDatabase creates it through the admin
+ * "postgres" database before initializing. Turso has no management API —
+ * its hosted target must already exist.
+ */
+declare function openCliDb(target?: string | CliDatabaseConfig, opts?: {
+    initialize?: boolean;
+    create?: boolean;
+}): Promise<CliDb>;
+
+/**
+ * server.ts — `wod server` (alias `serve`) / `wod playground` (Bun-only front
+ * door).
+ *
+ * Serves the packaged engine stack: the shared fetch handler shipped in this
+ * package (the same code the Docker image serves) plus the frontend build
+ * packaged under the engine's dist/web/ — no repository checkout, no runtime
+ * build.
+ *
+ * server      probes the configured database first (never creates schema —
+ *             that's `wod init`), then serves API + SPA.
+ * playground  serves the browser-storage SPA build and never opens a database
+ *             (every /api request answers 404).
+ *
+ * Retains the event loop until SIGINT/SIGTERM; shutdown drains in-flight
+ * requests before closing the database.
+ */
+
+type WriteOut = (text: string) => void;
+type CliServerMode = 'server' | 'playground';
+interface CliServerOptions {
+    /** Resolved database configuration. REQUIRED for 'server'; ignored — never
+     * opened or validated — for 'playground'. */
+    database?: CliDatabaseConfig;
+    host?: string;
+    port?: string;
+    /** Explicit dist directory (flag or PLAYGROUND_DIST); must already exist. */
+    dist?: string;
+    /** Merged CLI environment (process env + .env). */
+    env: Record<string, string | undefined>;
+}
+/**
+ * Start the shared server for `wod server` / `wod playground`. Throws on any
+ * startup failure; on success it never returns until SIGINT/SIGTERM (drain,
+ * close database, exit 0).
+ */
+declare function runCliServer(mode: CliServerMode, options: CliServerOptions, writeOut: WriteOut): Promise<void>;
+
+export { type CliDatabaseConfig, type CliDb, type CliParsedArgs, type CliServerMode, type CliServerOptions, type OutputFormat, PackLoadError, type ParseOptions, ParseSyntaxError, type QueryCliOptions, type RunOptions, WqlSyntaxError, cliMain, formatExecutionOutput, formatParseOutput, formatQueryOutput, loadCliEnvironment, loadLanguagePack, loadQueryData, openCliDb, parseCliArgs, readStdin, resolveDatabaseConfig, runCliServer, runExecution, runParse, runQueryCli };

package/dist/index.mjs

@@ -0,0 +1,12 @@
+import { createRequire } from 'module';
+export { PackLoadError, ParseSyntaxError, WqlSyntaxError, cliMain, formatExecutionOutput, formatParseOutput, formatQueryOutput, loadCliEnvironment, loadLanguagePack, loadQueryData, parseCliArgs, readStdin, resolveDatabaseConfig, runExecution, runParse, runQueryCli } from './chunk-B3QJYJVI.mjs';
+export { runCliServer } from './chunk-32FASQP5.mjs';
+export { openCliDb } from './chunk-EUQWEX6Z.mjs';
+import './chunk-K3GZZFAC.mjs';
+import './chunk-6L5ZDZJ7.mjs';
+
+if (typeof globalThis.require === 'undefined') {
+  try { globalThis.require = createRequire(import.meta.url); } catch {}
+}
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/server/app.cjs

@@ -0,0 +1,299 @@
+'use strict';
+
+var path = require('path');
+var promises = require('fs/promises');
+var fs = require('fs');
+var sql = require('@bitcobblers/wod-wiki-storage/sql');
+var wodWikiStorage = require('@bitcobblers/wod-wiki-storage');
+
+// src/server/app.ts
+
+// src/server/errors.ts
+var HttpError = class extends Error {
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "HttpError";
+  }
+  status;
+  code;
+};
+var json = (value, status) => new Response(JSON.stringify(value), { status, headers: { "content-type": "application/json" } });
+function bunFile(path) {
+  const bun = globalThis;
+  if (!bun.Bun) throw new Error("the wod-wiki server handler requires the Bun runtime (https://bun.sh)");
+  return bun.Bun.file(path);
+}
+var plain = (body, status) => new Response(body, { status, headers: { "content-type": "text/plain; charset=utf-8" } });
+var notFound = () => json({ error: "not found" }, 404);
+var methodNotAllowed = () => json({ error: "method not allowed" }, 405);
+var noContent = () => new Response(null, { status: 204 });
+var qget = (url, name) => url.searchParams.get(name) ?? void 0;
+function jsonParam(url, name) {
+  const raw = qget(url, name);
+  if (raw === void 0) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new HttpError(400, `invalid JSON in ?${name}`);
+  }
+}
+function rangeParam(url) {
+  const v = jsonParam(url, "range");
+  if (v === void 0) return void 0;
+  if (v !== null && typeof v === "object" && !Array.isArray(v)) return v;
+  return { only: v };
+}
+function countParam(url) {
+  const raw = qget(url, "count");
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 0) throw new HttpError(400, "invalid ?count");
+  return Math.trunc(n);
+}
+async function readJsonBody(req, maxBytes) {
+  const body = await req.text();
+  if (maxBytes !== void 0 && body.length > maxBytes) {
+    throw new HttpError(413, `domain query body exceeds ${maxBytes} bytes`);
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    throw new HttpError(400, "body must be valid JSON");
+  }
+}
+function txOps(value) {
+  if (!Array.isArray(value)) throw new HttpError(400, "tx body must be {ops: []}");
+  return value.map((op) => {
+    if (op === null || typeof op !== "object" || Array.isArray(op) || !("store" in op) || typeof op.store !== "string" || !("op" in op)) {
+      throw new HttpError(400, "tx op must have a store and operation");
+    }
+    const def = sql.storeDefinition(op.store);
+    const store = def.name;
+    switch (op.op) {
+      case "put":
+        if (!("value" in op)) throw new HttpError(400, "put requires value");
+        return { op: "put", store, value: op.value };
+      case "delete":
+        if (!("key" in op)) throw new HttpError(400, "delete requires key");
+        return { op: "delete", store, key: op.key };
+      case "clear":
+        return { op: "clear", store };
+      case "check": {
+        if (!("key" in op) || !("value" in op)) throw new HttpError(400, "check requires key and value");
+        const scalar = (key) => typeof key === "string" || typeof key === "number" && Number.isFinite(key);
+        if (!scalar(op.key) && !(Array.isArray(op.key) && op.key.length > 0 && op.key.every(scalar))) {
+          throw new HttpError(400, "check requires a scalar key or non-empty scalar tuple");
+        }
+        if (op.value !== null && (typeof op.value !== "object" || Array.isArray(op.value))) {
+          throw new HttpError(400, "check value must be a row or null");
+        }
+        const parts = Array.isArray(op.key) ? op.key : [op.key];
+        if (parts.length !== def.keyPath.length) throw new HttpError(400, "check key arity must match the store");
+        if (op.value !== null) {
+          let rowKey;
+          try {
+            rowKey = wodWikiStorage.keyFromValue(def, op.value);
+          } catch {
+            throw new HttpError(400, "check row must have its primary key");
+          }
+          if (JSON.stringify(rowKey) !== JSON.stringify(op.key)) throw new HttpError(400, "check row primary key must match key");
+        }
+        return { op: "check", store, key: op.key, value: op.value };
+      }
+      default:
+        throw new HttpError(400, "tx op must be put | delete | clear | check");
+    }
+  });
+}
+var MIME = {
+  html: "text/html; charset=utf-8",
+  js: "text/javascript; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  css: "text/css; charset=utf-8",
+  json: "application/json; charset=utf-8",
+  map: "application/json; charset=utf-8",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  webmanifest: "application/manifest+json",
+  xml: "application/xml",
+  txt: "text/plain; charset=utf-8"
+};
+async function realpathSafe(path) {
+  try {
+    return await promises.realpath(path);
+  } catch {
+    return void 0;
+  }
+}
+async function serveFile(real, rel) {
+  const cache = rel.includes("seed/chunks/") ? "public, max-age=31536000, immutable" : "no-cache";
+  const ext = rel.slice(rel.lastIndexOf(".") + 1).toLowerCase();
+  return new Response(bunFile(real), {
+    headers: { "content-type": MIME[ext] ?? "application/octet-stream", "cache-control": cache }
+  });
+}
+async function serveSpaShell(distRoot) {
+  const index = await realpathSafe(path.join(distRoot, "index.html"));
+  if (index && (index === distRoot || index.startsWith(distRoot + path.sep)) && await promises.stat(index).then((s) => s.isFile(), () => false)) {
+    return new Response(bunFile(index), {
+      headers: { "content-type": MIME.html, "cache-control": "no-cache" }
+    });
+  }
+  return void 0;
+}
+async function staticResponse(distRoot, method, pathname) {
+  if (method !== "GET") return plain("method not allowed", 405);
+  if (!distRoot) {
+    return plain("wod-wiki-api: playground dist not found. Set PLAYGROUND_DIST or run the playground server build.", 503);
+  }
+  let rel;
+  try {
+    rel = decodeURIComponent(pathname).replace(/^\/+/, "");
+  } catch {
+    return plain("bad request", 400);
+  }
+  if (rel === "") rel = "index.html";
+  const parts = rel.split("/");
+  if (parts.some((p) => p === "..")) return plain("forbidden", 403);
+  const base = parts[parts.length - 1] ?? "";
+  const hasExtension = base.includes(".");
+  const abs = path.resolve(distRoot, ...parts);
+  const real = await realpathSafe(abs);
+  if (real && (real === distRoot || real.startsWith(distRoot + path.sep))) {
+    const info = await promises.stat(real).then((s) => s.isFile(), () => false);
+    if (info) return serveFile(real, rel);
+  }
+  if (!hasExtension) {
+    const shell = await serveSpaShell(distRoot);
+    if (shell) return shell;
+  }
+  return plain("not found", 404);
+}
+async function storeRoutes(db, method, sub, url, req) {
+  let inner = sub.slice("/v1/".length);
+  if (inner.endsWith("/")) inner = inner.slice(0, -1);
+  if (inner === "") return notFound();
+  const segments = inner.split("/");
+  let name;
+  let action;
+  if (segments.length === 1) {
+    name = segments[0];
+  } else if (segments.length === 2) {
+    [name, action] = segments;
+  } else if (segments.length === 3 && segments[1] === "index" && segments[2] !== "") {
+    [name, , action] = segments;
+    action = `index/${action}`;
+  } else {
+    return notFound();
+  }
+  const def = sql.storeDefinition(name);
+  const range = rangeParam(url);
+  const count = countParam(url);
+  if (action === "get" && method === "GET") {
+    const key = jsonParam(url, "key");
+    if (key === void 0) throw new HttpError(400, "missing ?key");
+    const row = await sql.getRow(db, def, key);
+    return row === void 0 ? notFound() : json(row, 200);
+  }
+  if (action === "all" && method === "GET") {
+    return json(await sql.listRows(db, def, range, count), 200);
+  }
+  if (action === "count" && method === "GET") {
+    const indexName = qget(url, "index");
+    const n = indexName ? await sql.countRows(db, def, range, indexName) : await sql.countRows(db, def, range);
+    return json({ count: Number(n) }, 200);
+  }
+  if (action === "clear" && method === "POST") {
+    await db.transaction((tx) => sql.refreshDomain(tx, [{ op: "clear", store: def.name }]));
+    return noContent();
+  }
+  if (action?.startsWith("index/") && method === "GET") {
+    return json(await sql.listRows(db, def, range, count, action.slice("index/".length)), 200);
+  }
+  if (action === void 0 && method === "PUT") {
+    const parsed = await readJsonBody(req);
+    const value = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "value" in parsed ? parsed.value : void 0;
+    if (value === void 0) throw new HttpError(400, "body must be {value: ...}");
+    const [key] = await db.transaction((tx) => sql.refreshDomain(tx, [{ op: "put", store: def.name, value }]));
+    return json({ key }, 200);
+  }
+  if (action === void 0 && method === "DELETE") {
+    const keyParam = jsonParam(url, "key");
+    const target = keyParam !== void 0 ? keyParam : range;
+    if (target === void 0 || target === null) throw new HttpError(400, "DELETE requires ?key or ?range");
+    await db.transaction((tx) => sql.refreshDomain(tx, [{ op: "delete", store: def.name, key: target }]));
+    return noContent();
+  }
+  return methodNotAllowed();
+}
+async function apiRoutes(db, req, method, sub, url) {
+  if (sub === "/health") {
+    return json({ ok: true, driver: db.dialect }, 200);
+  }
+  if (sub === "/v1/wipe" && method === "POST") {
+    await db.transaction(async (tx) => {
+      await sql.wipeRows(tx);
+      await sql.wipeDomain(tx);
+    });
+    return noContent();
+  }
+  if (sub === "/v1/tx" && method === "POST") {
+    const parsed = await readJsonBody(req);
+    const ops = typeof parsed === "object" && parsed !== null && "ops" in parsed ? parsed.ops : void 0;
+    const parsedOps = txOps(ops);
+    const results = await db.transaction((tx) => sql.refreshDomain(tx, parsedOps));
+    return json({ results }, 200);
+  }
+  if (sub === "/v1/query") {
+    if (method !== "POST") return methodNotAllowed();
+    const body = await readJsonBody(req, sql.MAX_BODY);
+    return json(await sql.handleDomainQuery(db, body), 200);
+  }
+  if (sub.startsWith("/v1/")) return storeRoutes(db, method, sub, url, req);
+  return notFound();
+}
+function distRootOf(playgroundDist) {
+  if (!playgroundDist) return void 0;
+  try {
+    return fs.realpathSync(playgroundDist);
+  } catch {
+    return void 0;
+  }
+}
+function createHandler(db, options) {
+  const distRoot = distRootOf(options.playgroundDist);
+  return async (request) => {
+    try {
+      const url = new URL(request.url);
+      const method = request.method === "HEAD" ? "GET" : request.method;
+      const path = url.pathname;
+      const response = path === "/api" || path.startsWith("/api/") ? db ? await apiRoutes(db, request, method, path.slice("/api".length) || "/", url) : notFound() : await staticResponse(distRoot, method, path);
+      return response;
+    } catch (e) {
+      if (e instanceof HttpError || e instanceof sql.StorageError) {
+        const status = e.status;
+        if (status >= 500) console.error("[wod-wiki-api]", e.message);
+        const body = { error: status >= 500 ? "internal error" : e.message };
+        if (e.code) body.code = e.code;
+        return json(body, status);
+      }
+      console.error("[wod-wiki-api]", e);
+      return json({ error: "internal error" }, 500);
+    }
+  };
+}
+
+exports.createHandler = createHandler;
+//# sourceMappingURL=app.cjs.map
+//# sourceMappingURL=app.cjs.map