Batch RTL SVG Icon Generation with the Runner and Automation Scripts

Confirm the contract before coding

Fetch the schema so your script targets the real shape (no options, single file, engine mode).

$ curl -H "Authorization: Bearer $JAD_KEY" \
     https://jadapps.com/api/v1/tools/svg-rtl-mirror

{
  "input":  { "isGenerative": false,
              "acceptsMultiple": false,
              "options": [] },
  "output": { "type": "svg" },
  "execution": { "runnerMode": "engine" },
  "minTier": "pro"
}

The hosted /run endpoint refuses uploads

Proof that files never go to JAD's servers — the hosted run endpoint returns a 400 and hands you the local runner address.

$ curl -X POST -H "Authorization: Bearer $JAD_KEY" \
     -d '{"text":"<svg…>"}' \
     https://jadapps.com/api/v1/tools/svg-rtl-mirror/run

HTTP/1.1 400 Bad Request
{
  "error": "Runner required",
  "runnerEndpoint": "http://127.0.0.1:9789/v1/tools/svg-rtl-mirror/run",
  "installRunner": "https://jadapps.com/docs/runner"
}

Idempotent batch script (Node)

Reads an allowlist, flips only the marked icons via the local runner, caches by content hash, and writes a manifest.

import { readFile, writeFile, mkdir } from "node:fs/promises";
import { createHash } from "node:crypto";
import pLimit from "p-limit";

const RUNNER = "http://127.0.0.1:9789/v1/tools/svg-rtl-mirror/run";
const allow  = JSON.parse(await readFile("mirror.json", "utf8")); // { name: true|false }
const cache  = JSON.parse(await readFile(".rtlcache.json", "utf8").catch(() => "{}"));
const limit  = pLimit(6);
await mkdir("icons-rtl", { recursive: true });

const jobs = Object.entries(allow)
  .filter(([, mirror]) => mirror === true)
  .map(([name]) => limit(async () => {
    const src  = await readFile(`icons/${name}.svg`, "utf8");
    const hash = createHash("sha1").update(src).digest("hex");
    if (cache[name] === hash) return { name, skipped: true };   // idempotent
    const res  = await fetch(RUNNER, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({ text: src, options: {} }),
    });
    const out  = await res.text();
    await writeFile(`icons-rtl/${name}.svg`, out);
    cache[name] = hash;
    return { name, skipped: false };
  }));

const results = await Promise.all(jobs);
await writeFile(".rtlcache.json", JSON.stringify(cache, null, 2));
console.log(`flipped ${results.filter(r => !r.skipped).length}, ` +
            `skipped ${results.filter(r => r.skipped).length}`);

Sprite sheets need a split-flip-rebuild pass

There is no sprite-aware flip. Decompose, flip the directional symbols, rebuild — a three-step pipeline.

icons.svg (sprite with many <symbol>)
  1. split each <symbol> into a standalone <svg>
  2. for symbols in the mirror allowlist:
         POST to the runner → flipped SVG
  3. rebuild → /svg-tools/svg-sprite-builder → icons-rtl.svg

Reference #icon-name from whichever sprite matches the page dir.

Skip text-bearing icons (or outline first)

The flipper reverses live text. Either keep those icons LTR or outline them before flipping.

for (const name of allowlist) {
  const src = await readFile(`icons/${name}.svg`, "utf8");
  if (src.includes("<text")) {
    // outline via svg-font-to-path first, or move to 'keep' bucket
    console.warn(`${name}: has <text>; flipping would reverse it`);
    continue;
  }
  // …POST to runner…
}

The JAD-hosted run endpoint never accepts uploads — it returns 400 Runner required with the local runner address. This is the privacy design, not a bug. Send the payload to your paired runner at 127.0.0.1:9789 instead.

The schema reports acceptsMultiple: false. There is no icons[] / flags[] batch request. Batch is orchestrated by your script issuing one call per icon (concurrency capped client-side). Don't build against a non-existent multipart batch shape.

The tool does not analyse geometry or return a 'should this mirror' score. There is no auto-detect feature. You must supply the mirror/keep decision via your own allowlist; the tool flips exactly what you send it.

The schema's options array is empty — there are no parameters. Any options object you send is effectively a no-op; the flip is fully determined by the viewBox width. Keep the payload to { text }.

Engine and browser both default the flip width to 24 when there is no viewBox or the width is 0. On a non-24 grid the output is off-frame. Normalise viewBoxes in a pre-step (e.g. svg-viewbox-fixer) before the batch run.

Flipping reverses live text into unreadable glyphs. Detect <text> in your loop and either skip those icons or route them through svg-font-to-path first. The flipper itself does nothing special for text.

If nothing is listening on 127.0.0.1:9789, your POST fails to connect. Confirm the @jadapps/runner is installed, paired, and running. Until then the only working response from the platform is the hosted endpoint's 400 with pairing instructions.

minTier is pro. A free key cannot run this tool. Upgrade to Pro to use RTL Mirror via the runner. Pro also raises the per-file SVG limit to 50 MB, far above any icon.

Never flip the whole icons/ folder — logos and other Keep-bucket assets would be mirrored. Iterate only over allowlist entries marked true. The tool has no guard against flipping a logo.