@zvndev/darkmown 1.5.0 → 2.0.1

package/src/cli.js

@@ -8,7 +8,14 @@ import { handleApiRequest } from "./api-runner.js";
 import { buildSite } from "./builder.js";
 import { createPaths } from "./config.js";
 import { DEPLOY_TARGETS, deploy } from "./deploy.js";
-import { devClientPath, devClientScript, devEventsPath, injectDevClient } from "./dev.js";
+import {
+  buildFailedPage,
+  createRebuildQueue,
+  devClientPath,
+  devClientScript,
+  devEventsPath,
+  injectDevClient
+} from "./dev.js";
 import { discoverRoutes, isDraft, outputPathForRoute } from "./router.js";
 import { availableTemplates, initProject } from "./scaffold.js";
 import { contentType, resolvePublicFile, serve } from "./statics.js";
@@ -69,7 +76,16 @@ export async function run(argv, env = {}) {
     // `--drafts` includes `draft: true` pages in the build + feeds (staging);
     // the default production build excludes them at route discovery.
     const includeDrafts = argv.includes("--drafts");
-    const result = buildSite(cwd, { target, includeDrafts });
+    // Dev-server plumbing: `--dep-map` writes the per-route dependency map;
+    // `--changed <path>` (repeatable, implies --dep-map) attempts an incremental
+    // rebuild of just the affected routes, with a full-rebuild fallback on any
+    // uncertainty. Not part of the public CLI surface.
+    const changed = flagValues(argv, "--changed");
+    const depMap = argv.includes("--dep-map") || changed.length > 0;
+    // Dev rebuilds pass this so the site_url/placeholder feed hints print once per
+    // session (from the initial in-process build) instead of on every rebuild.
+    const quietFeedHints = argv.includes("--quiet-feed-hints");
+    const result = buildSite(cwd, { target, includeDrafts, changed, depMap, quietFeedHints });
     log(buildSummary(result, path.relative(cwd, result.distRoot)));
     if (target === "cloudflare")
       log("Emitted dist/_worker.js for Cloudflare Pages api/* functions");
@@ -128,8 +144,6 @@ function startDevServer({ cwd, log, warn, error }) {
   const distRoot = path.join(cwd, "dist");
   /** @type {Set<import("node:http").ServerResponse>} */
   const clients = new Set();
-  /** @type {ReturnType<typeof setTimeout> | undefined} */
-  let timer;
   /** @type {string | undefined} Last build failure, replayed to clients on connect. */
   let lastBuildError;
 
@@ -138,20 +152,30 @@ function startDevServer({ cwd, log, warn, error }) {
   // see it on connect; the next successful rebuild clears it via `reload`.
   // Dev builds + serves `draft: true` pages (they're work-in-progress you want
   // to preview); the dev client stamps a visible banner so a draft is obvious.
+  // `depMap: true` writes the per-route dependency map that lets the rebuilds
+  // below be incremental for site/ content changes.
   try {
-    buildSite(cwd, { includeDrafts: true });
+    buildSite(cwd, { includeDrafts: true, depMap: true });
   } catch (err) {
     lastBuildError = (err instanceof Error ? err.message : String(err)).trim();
-    error(lastBuildError);
+    error(`✗ Initial build failed:\n${lastBuildError}`);
   }
 
   // Rebuild in a child process so changes to Darkmown's own src/ always load
   // fresh modules — an in-process rebuild would reuse the stale import cache.
-  const rebuild = () => {
-    clearTimeout(timer);
-    timer = setTimeout(() => {
+  // A site/ change additionally passes the changed path(s), so the child can
+  // rebuild only the routes whose dependency graph contains them (the builder
+  // falls back to a full rebuild on any uncertainty). A src/ change — or an
+  // event with no attributable file — queues `null`, forcing the full rebuild.
+  // The queue serializes the children: every build read-modify-writes the
+  // dependency map, so overlapping children could persist a stale map and
+  // silently stop rebuilding affected routes.
+  const runBuild = (/** @type {string[]} */ changed) =>
+    new Promise((/** @type {(value?: void) => void} */ done) => {
+      const args = [cliPath, "build", "--drafts", "--dep-map", "--quiet-feed-hints"];
+      for (const file of changed) args.push("--changed", file);
       const started = performance.now();
-      execFile(process.execPath, [cliPath, "build", "--drafts"], { cwd }, (err, stdout, stderr) => {
+      execFile(process.execPath, args, { cwd }, (err, stdout, stderr) => {
         if (err) {
           const message = (stderr || stdout || String(err)).trim();
           lastBuildError = message;
@@ -160,6 +184,7 @@ function startDevServer({ cwd, log, warn, error }) {
             clients,
             `event: builderror\ndata: ${JSON.stringify({ message: message.slice(0, 4000) })}\n\n`
           );
+          done();
           return;
         }
         lastBuildError = undefined;
@@ -167,16 +192,25 @@ function startDevServer({ cwd, log, warn, error }) {
         if (stderr.trim()) warn(stderr.trim());
         broadcast(clients, `event: reload\ndata: ${JSON.stringify({ elapsed })}\n\n`);
         log(`${stdout.trim().split("\n").at(-1)} (${elapsed}ms)`);
+        done();
       });
-    }, 30);
-  };
+    });
+  const queue = createRebuildQueue(runBuild);
 
   /** @type {import("node:fs").FSWatcher[]} */
   const watchers = [];
   for (const dir of ["site", "src"]) {
     const abs = path.join(cwd, dir);
     if (fs.existsSync(abs)) {
-      watchers.push(fs.watch(abs, { recursive: true }, rebuild));
+      watchers.push(
+        fs.watch(abs, { recursive: true }, (_event, filename) => {
+          queue.change(
+            dir === "site" && filename
+              ? path.join(dir, filename.toString()).replaceAll(path.sep, "/")
+              : null
+          );
+        })
+      );
     }
   }
 
@@ -211,7 +245,7 @@ function startDevServer({ cwd, log, warn, error }) {
     // throw on either path (e.g. a stat/read error) becomes a clean 500.
     handleApiRequest({ apiDir, req, res })
       .then((handled) => {
-        if (!handled) serveDev(distRoot, url, res, draftRoutes(cwd));
+        if (!handled) serveDev(distRoot, url, res, draftRoutes(cwd), () => lastBuildError);
       })
       .catch((err) => {
         res.writeHead(500, { "content-type": "text/plain" });
@@ -221,13 +255,19 @@ function startDevServer({ cwd, log, warn, error }) {
 
   return new Promise((resolve) => {
     server.listen(port, host, () => {
-      log(`Darkmown dev server ready at http://${host}:${port}`);
+      // Never claim a clean start over a broken build: when the initial build
+      // failed, say so on the ready line and point at the fix-to-retry flow.
+      log(
+        lastBuildError
+          ? `Darkmown dev server ready at http://${host}:${port} — but the initial build FAILED (see the error above). Routes show it until you fix the file; rebuilds run on save.`
+          : `Darkmown dev server ready at http://${host}:${port}`
+      );
       log(`Live compiler watching site/ and src/`);
       resolve({
         command: "dev",
         server,
         close: () => {
-          clearTimeout(timer);
+          queue.close();
           for (const watcher of watchers) watcher.close();
           for (const client of clients) client.end();
           clients.clear();
@@ -271,11 +311,23 @@ function startPreviewServer({ cwd, log, error }) {
  * @param {import("node:http").ServerResponse} res
  * @param {Set<string>} draftFiles Absolute dist HTML paths of draft pages — each
  *   gets the dev-only draft banner injected (never written to disk).
+ * @param {() => string | undefined} buildError Reads the last recorded build
+ *   failure (undefined once a build succeeds).
  * @returns {void}
  */
-function serveDev(distRoot, url, res, draftFiles) {
+function serveDev(distRoot, url, res, draftFiles, buildError) {
   const file = resolvePublicFile(distRoot, url);
   if (!file || !fs.existsSync(file)) {
+    // An HTML route with no dist output while the last build FAILED is almost
+    // certainly unbuilt because of that failure — serve the compile error (the
+    // SSE overlay replays it too), not the misleading "hidden or not created"
+    // 404. Non-HTML assets and traversal-rejected URLs still 404 normally.
+    const failure = buildError();
+    if (failure && file?.endsWith(".html")) {
+      res.writeHead(500, { "content-type": "text/html; charset=utf-8" });
+      res.end(buildFailedPage(failure));
+      return;
+    }
     serve(distRoot, url, res);
     return;
   }
@@ -353,11 +405,19 @@ Authoring:
  * (home `site_url` set), the sitemap URL and RSS post counts — e.g.
  * `Built 14 routes, sitemap (14 urls), rss (6 posts) into dist`. When no
  * `site_url` is set the feed clauses are omitted (a hint was already warned).
- * @param {{ routes: unknown[], feeds: { sitemap: number | null, rss: number | null } }} result
+ * An incremental (dev `--changed`) build reports what it actually rebuilt —
+ * `Rebuilt 2 of 14 routes (/blog/, /blog/hello/) into dist` — naming the routes
+ * when there are few enough to read.
+ * @param {{ routes: unknown[], feeds: { sitemap: number | null, rss: number | null }, incremental?: { rebuilt: string[], total: number } }} result
  * @param {string} relativeRoot `dist` relative to cwd, for the message tail.
  * @returns {string}
  */
 export function buildSummary(result, relativeRoot) {
+  if (result.incremental) {
+    const { rebuilt, total } = result.incremental;
+    const shown = rebuilt.length > 0 && rebuilt.length <= 6 ? ` (${rebuilt.join(", ")})` : "";
+    return `Rebuilt ${rebuilt.length} of ${total} routes${shown} into ${relativeRoot}`;
+  }
   const parts = [`Built ${result.routes.length} routes`];
   if (result.feeds.sitemap !== null) parts.push(`sitemap (${result.feeds.sitemap} urls)`);
   if (result.feeds.rss !== null) parts.push(`rss (${result.feeds.rss} posts)`);
@@ -387,6 +447,24 @@ export function flagValue(argv, flag) {
   return undefined;
 }
 
+/**
+ * Read every occurrence of a repeatable `--flag value` / `--flag=value` option
+ * out of an argv tail (e.g. the dev server passing one `--changed <path>` per
+ * file in a debounced batch).
+ * @param {string[]} argv The argv tail.
+ * @param {string} flag The flag name, e.g. `"--changed"`.
+ * @returns {string[]} The values, in argv order (empty when the flag is absent).
+ */
+export function flagValues(argv, flag) {
+  /** @type {string[]} */
+  const values = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === flag && i + 1 < argv.length) values.push(argv[++i]);
+    else if (argv[i].startsWith(`${flag}=`)) values.push(argv[i].slice(flag.length + 1));
+  }
+  return values;
+}
+
 /**
  * Binary entry point: read argv, dispatch, and map failures to a clean
  * `✗`-prefixed line + exit code 1 — never a Node stack trace. The thrown Error

package/src/compiler/actions.js

@@ -0,0 +1,303 @@
+// ---------------------------------------------------------------------------
+// Actions: the `:button` action-expression parser (the validated `{ op, target,
+// value }` vocabulary) and its consumers — `:button` itself plus the two
+// action-driven markers `:effect` (run on state change) and `:every` (run on a
+// timer).
+//
+// Every handler receives the 0-based line `index` so its malformed/invalid
+// errors report `file:line` (via `at`) — matching the unclosed-block errors —
+// while keeping the message text and `Use:` hints intact.
+// ---------------------------------------------------------------------------
+
+import { at } from "./context.js";
+import {
+  escapeHtml,
+  resolveStateKey,
+  safeScriptJson,
+  stripQuotes,
+  validatePath
+} from "./interpolation.js";
+
+/**
+ * @typedef {import("./context.js").Ctx} Ctx
+ * @typedef {import("./context.js").Action} Action
+ */
+
+/**
+ * @param {string} line
+ * @param {Ctx} ctx
+ * @param {number} index 0-based line index for `file:line` errors.
+ * @returns {string}
+ */
+export function handleButton(line, ctx, index) {
+  const match = line.match(/^:button\s+"([^"]+)"\s*->\s*(.+)$/);
+  if (!match) throw new Error(`Malformed :button in ${at(ctx, index)}: ${line}`);
+  ctx.comp.assets.runtime = true;
+  const action = parseAction(match[2], ctx);
+  if (Array.isArray(action)) {
+    return `<button type="button" data-wd-actions="${escapeHtml(JSON.stringify(action))}">${escapeHtml(match[1])}</button>`;
+  }
+  const valueAttr =
+    action.value === undefined
+      ? ""
+      : ` data-wd-value="${escapeHtml(JSON.stringify(action.value))}"`;
+  return `<button type="button" data-wd-action="${action.op}" data-wd-target="${action.target}"${valueAttr}>${escapeHtml(match[1])}</button>`;
+}
+
+const EFFECT_USE =
+  "Use: :effect watchedState -> action[; action…] (actions use the :button vocabulary).";
+
+/**
+ * Parse `:effect <watched> -> <actions>` into a zero-output marker the runtime
+ * watches: when `<watched>` state changes, it runs `<actions>` (the same `:button`
+ * action vocabulary, `;`-chained). For arbitrary side effects beyond `:computed`
+ * (derive state) and fetch deps (auto-refetch).
+ * @param {string} line
+ * @param {Ctx} ctx
+ * @param {number} index 0-based line index for `file:line` errors.
+ * @returns {string}
+ */
+export function handleEffect(line, ctx, index) {
+  const match = line.match(/^:effect\s+([A-Za-z_$][\w$.]*)\s*->\s*(.+)$/);
+  if (!match) throw new Error(`Malformed :effect in ${at(ctx, index)}: ${line}. ${EFFECT_USE}`);
+  const segs = validatePath(match[1], ctx, EFFECT_USE);
+  const key = resolveStateKey(segs[0], ctx);
+  if (!key)
+    throw new Error(
+      `:effect watches unknown state "${segs[0]}" in ${ctx.file}. Declare it first with :state ${segs[0]} = ...`
+    );
+  ctx.comp.assets.runtime = true;
+  const watch = [key, ...segs.slice(1)].join(".");
+  const action = parseAction(match[2], ctx);
+  const actions = Array.isArray(action) ? action : [action];
+  return `<script type="application/json" data-wd-effect>${safeScriptJson({ watch, actions })}</script>`;
+}
+
+const EVERY_USE =
+  "Use: :every <duration> -> action[; action…] — duration like 5s, 500ms, or 2m (actions use the :button vocabulary).";
+
+/**
+ * Parse a duration token into milliseconds: `<int>[ms|s|m]`, defaulting to ms.
+ * @param {string} raw
+ * @returns {number | null}
+ */
+function parseDuration(raw) {
+  const match = raw.trim().match(/^(\d+)(ms|s|m)?$/);
+  if (!match) return null;
+  const n = Number(match[1]);
+  return match[2] === "s" ? n * 1000 : match[2] === "m" ? n * 60000 : n;
+}
+
+/**
+ * Parse `:every <duration> -> <actions>` into a marker the runtime drives on a
+ * timer: every `<duration>` it runs `<actions>` (the same `:button` vocabulary,
+ * `;`-chained), and the interval auto-pauses while the tab is hidden. The one time
+ * primitive — behind live polling (`:every 5s -> board refetch`), clocks and
+ * countdowns (`:every 1s -> seconds++`), and slideshow autoplay (`:every 4s -> slide++`).
+ * @param {string} line
+ * @param {Ctx} ctx
+ * @param {number} index 0-based line index for `file:line` errors.
+ * @returns {string}
+ */
+export function handleEvery(line, ctx, index) {
+  const match = line.match(/^:every\s+(\S+)\s*->\s*(.+)$/);
+  if (!match) throw new Error(`Malformed :every in ${at(ctx, index)}: ${line}. ${EVERY_USE}`);
+  const ms = parseDuration(match[1]);
+  if (ms == null || ms <= 0) {
+    throw new Error(
+      `:every duration "${match[1]}" is not valid in ${at(ctx, index)}. ${EVERY_USE}`
+    );
+  }
+  ctx.comp.assets.runtime = true;
+  const action = parseAction(match[2], ctx);
+  const actions = Array.isArray(action) ? action : [action];
+  return `<script type="application/json" data-wd-every>${safeScriptJson({ ms, actions })}</script>`;
+}
+
+const ACTION_USE =
+  'Use: name++, name--, n += k, n -= k, name = v, flag toggle, list append/prepend v, list toggle v, list remove v, x clear, obj merge other, obj delete key, name reset — chain with ";".';
+
+/**
+ * Parse a `:button` action expression into a validated `{ op, target, value }`,
+ * or — when `;`-separated — an ordered array of them applied in sequence.
+ * @param {string} raw
+ * @param {Ctx} ctx
+ * @returns {Action | Action[]}
+ */
+function parseAction(raw, ctx) {
+  const parts = raw
+    .split(";")
+    .map((p) => p.trim())
+    .filter(Boolean);
+  if (parts.length > 1) return parts.map((part) => parseSingleAction(part, raw, ctx));
+  return parseSingleAction(raw.trim(), raw, ctx);
+}
+
+/**
+ * Parse one (non-`;`) action expression into a validated `{ op, target, value }`.
+ * Targets may be dotted paths (`cart.count`); a bare name is a 1-segment path.
+ * @param {string} expression
+ * @param {string} raw The full original action source (for error context).
+ * @param {Ctx} ctx
+ * @returns {Action}
+ */
+function parseSingleAction(expression, raw, ctx) {
+  const PATH = "[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*)*";
+  /** @param {string} name @returns {string} */
+  const resolveTarget = (name) => {
+    const segs = validatePath(name, ctx, ACTION_USE);
+    const key = resolveStateKey(segs[0], ctx);
+    if (!key) {
+      throw new Error(
+        `Button action targets unknown state "${segs[0]}" in ${ctx.file}. Declare it first with :state ${segs[0]} = ...`
+      );
+    }
+    return [key, ...segs.slice(1)].join(".");
+  };
+
+  const increment = expression.match(new RegExp(`^(${PATH})\\+\\+$`));
+  if (increment) return { op: "inc", target: resolveTarget(increment[1]) };
+  const decrement = expression.match(new RegExp(`^(${PATH})--$`));
+  if (decrement) return { op: "dec", target: resolveTarget(decrement[1]) };
+  const sub = expression.match(new RegExp(`^(${PATH})\\s*-=\\s*(.+)$`));
+  if (sub)
+    return { op: "sub", target: resolveTarget(sub[1]), value: parseActionLiteral(sub[2], ctx) };
+  // Per-row: carry the current loop item into another list — `cart += product`.
+  // Only inside a reactive @loop; the runtime resolves the row from the DOM.
+  const add = expression.match(new RegExp(`^(${PATH})\\s*\\+=\\s*(.+)$`));
+  if (add) {
+    const rhs = add[2].trim();
+    if (ctx.loopItem && rhs === ctx.loopItem) {
+      const target = resolveTarget(add[1]);
+      if (!Array.isArray(ctx.comp.state.get(target))) {
+        throw new Error(
+          `Button action "${raw}" needs ${add[1]} to be a :state list (declare it "${add[1]} = []") in ${ctx.file}.`
+        );
+      }
+      return { op: "append-row", target };
+    }
+    const target = resolveTarget(add[1]);
+    const value = parseActionLiteral(rhs, ctx);
+    if (Array.isArray(ctx.comp.state.get(target))) return { op: "append", target, value };
+    if (typeof value === "number") return { op: "add", target, value };
+    throw new Error(
+      `Unsupported button action "${raw}" in ${ctx.file}. += with non-number values requires a list state target — declare it "${add[1]} = []".`
+    );
+  }
+  // `flag toggle` (no operand) → boolean flip; `list toggle v` → member-toggle.
+  const toggle = expression.match(new RegExp(`^(${PATH})\\s+toggle(?:\\s+(.+))?$`));
+  if (toggle) {
+    const target = resolveTarget(toggle[1]);
+    if (toggle[2] === undefined) return { op: "toggle", target };
+    return { op: "member-toggle", target, value: parseActionLiteral(toggle[2], ctx) };
+  }
+  const prepend = expression.match(new RegExp(`^(${PATH})\\s+(?:append|prepend)\\s+(.+)$`));
+  if (prepend) {
+    const op = expression.includes(" prepend ") ? "prepend" : "append";
+    return { op, target: resolveTarget(prepend[1]), value: parseActionLiteral(prepend[2], ctx) };
+  }
+  // Per-row: remove the current row from the list being looped — `todos remove todo`.
+  // Disambiguation: operand IS the loop item name → `remove` (current row);
+  // otherwise the operand is a value → `remove-value`.
+  const remove = expression.match(new RegExp(`^(${PATH})\\s+remove\\s+(.+)$`));
+  if (remove) {
+    const operand = remove[2].trim();
+    if (ctx.loopItem && operand === ctx.loopItem) {
+      // A nested (item-relative) loop has a loop item but no top-level state key —
+      // its source is a path off the outer row, which the runtime's row-remove
+      // can't target. Fail loud with the honest workaround.
+      if (!ctx.loopKey) {
+        throw new Error(
+          `Button action "${raw}" can't delete a row of a nested (item-relative) loop in ${ctx.file}. Per-row "remove" needs a top-level :state/:store list; carry the row into one (cart += ${ctx.loopItem}) and remove it there.`
+        );
+      }
+      if (resolveStateKey(remove[1], ctx) !== ctx.loopKey) {
+        throw new Error(
+          `Button action "${raw}" must target the :state list being looped (@loop ${remove[1]} into ${ctx.loopItem}) in ${ctx.file}.`
+        );
+      }
+      return { op: "remove", target: ctx.loopKey };
+    }
+    return {
+      op: "remove-value",
+      target: resolveTarget(remove[1]),
+      value: parseActionLiteral(operand, ctx)
+    };
+  }
+  const clear = expression.match(new RegExp(`^(${PATH})\\s+clear$`));
+  if (clear) return { op: "clear", target: resolveTarget(clear[1]) };
+  const merge = expression.match(new RegExp(`^(${PATH})\\s+merge\\s+(.+)$`));
+  if (merge)
+    return {
+      op: "merge",
+      target: resolveTarget(merge[1]),
+      value: parseMergeOperand(merge[2], ctx)
+    };
+  const del = expression.match(new RegExp(`^(${PATH})\\s+delete\\s+(.+)$`));
+  if (del)
+    return { op: "delete", target: resolveTarget(del[1]), value: parseActionLiteral(del[2], ctx) };
+  const reset = expression.match(new RegExp(`^(${PATH})\\s+reset$`));
+  if (reset) return { op: "reset", target: resolveTarget(reset[1]) };
+  // `name refetch` re-invokes the matching :fetch node. The target is the fetch
+  // key (bare name); the runtime finds the [data-wd-fetch-key] node and re-runs.
+  const refetch = expression.match(new RegExp(`^(${PATH})\\s+refetch$`));
+  if (refetch) return { op: "refetch", target: resolveTarget(refetch[1]) };
+  const assign = expression.match(new RegExp(`^(${PATH})\\s*=\\s*(.+)$`));
+  if (assign)
+    return {
+      op: "set",
+      target: resolveTarget(assign[1]),
+      value: parseActionLiteral(assign[2], ctx)
+    };
+  throw new Error(`Unsupported button action "${raw}" in ${ctx.file}. ${ACTION_USE}`);
+}
+
+/**
+ * `merge` operand: either an inline JSON object literal, or a state/store key
+ * name (emitted as a string the runtime resolves via getPath).
+ * @param {string} raw
+ * @param {Ctx} ctx
+ * @returns {unknown}
+ */
+function parseMergeOperand(raw, ctx) {
+  const value = raw.trim();
+  if (/^[A-Za-z_$][\w$]*$/.test(value)) {
+    const key = resolveStateKey(value, ctx);
+    if (!key)
+      throw new Error(
+        `Button action merge targets unknown state "${value}" in ${ctx.file}. Declare it first with :state ${value} = ...`
+      );
+    return key;
+  }
+  const parsed = parseActionLiteral(value, ctx);
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  throw new Error(
+    `Unsupported merge operand "${raw}" in ${ctx.file}. Use: obj merge other (a state key or an inline {…} object).`
+  );
+}
+
+/**
+ * @param {string} raw
+ * @param {Ctx} ctx
+ * @returns {unknown}
+ */
+function parseActionLiteral(raw, ctx) {
+  const value = raw.trim();
+  if (/^["'].*["']$/.test(value)) return stripQuotes(value);
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) return Number(value);
+  if (/^[[{]/.test(value)) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      throw new Error(
+        `Unsupported action literal "${raw}" in ${ctx.file}. Use: a quoted string, number, boolean, null, or valid JSON.`
+      );
+    }
+  }
+  throw new Error(
+    `Unsupported action literal "${raw}" in ${ctx.file}. Use: a quoted string, number, boolean, null, or valid JSON.`
+  );
+}