@glyphcss/compile 0.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Layoutit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# @glyphcss/compile
+
+Compile 3D meshes to **static glyphcss ASCII at build time** — a Vite plugin, a
+CLI, and a Node API. Because glyphcss renders to a single `<pre>` of text, a
+scene can be rendered ahead of time and inlined into HTML with **zero runtime
+JS**. Defaults match the glyphcss library exactly, so a compiled scene is
+byte-identical to what the runtime would render for the same inputs.
+
+## Vite plugin
+
+```ts
+// vite.config.ts
+import { glyphcssCompile } from "@glyphcss/compile/vite";
+export default { plugins: [glyphcssCompile()] };
+```
+
+```ts
+// import a mesh with `?glyph` → the build-time-rendered <pre> string
+import dog from "./dog.glb?glyph&autoCenter=1&rotX=60&rotY=45&zoom=0.5&cols=80&rows=30";
+document.querySelector("#app").innerHTML = dog; // no runtime, no WebGL
+```
+
+Works in any Vite pipeline — Astro, vanilla Vite, Vite-React (import the string
+and inject it). Query params map to the options below.
+
+## Install
+
+```sh
+npm i -g @glyphcss/compile     # global `glyphcss` command
+# or run ad hoc:
+npx @glyphcss/compile cube --auto-center
+# or as a build dep (Vite plugin / Node API):
+npm i -D @glyphcss/compile
+```
+
+It pulls in `glyphcss` + `@glyphcss/core` automatically. Ships a
+[**skill**](./SKILL.md) (`SKILL.md`) so coding agents know how to drive the CLI.
+
+## CLI
+
+```sh
+glyphcss cube --auto-center               # a primitive shape → color ASCII
+glyphcss dog.glb --auto-center            # a mesh file → ANSI color in the terminal
+glyphcss --polygons-json '[{"vertices":[[0,0,0],[2,0,0],[1,2,0]],"color":"#f00"}]'
+glyphcss dog.glb -f text                  # plain ASCII
+glyphcss dog.glb -f full -o dog.html      # full HTML document
+glyphcss dog.glb --fit 60 -f text         # fit width to 60 columns
+glyphcss model.obj --mtl other.mtl        # explicit OBJ material override
+```
+
+Input is a **mesh file** (`.obj/.glb/.gltf/.vox/.stl`), a **primitive shape** name
+(`cube`, `sphere`, `icosahedron`, `torus`, `cone`, … — 44 shapes), or **custom
+polygons** (`--polygons FILE.json` / `--polygons-json '…'`, an array of
+`{ vertices, color? }`).
+
+Output **`-f, --format`**: `ansi` (truecolor terminal), `text` (plain), `html`
+(a `<pre>`), or `full` (HTML doc). The default picks by destination — **terminal →
+ansi**, `-o` file → html, piped → text. Omit `--cols`/`--rows` and it auto-fits
+the grid + zoom to the model, cropped tight (give just one and the other adapts).
+The universal escape hatch — works in any pipeline (Hugo, Eleventy, CI, a Makefile).
+
+## Node API
+
+```ts
+import { compileFile, compileScene, loadMeshFromFile } from "@glyphcss/compile";
+
+const { html, inner, cols, rows } = await compileFile("dog.glb", { autoCenter: true });
+// or, with polygons you already have:
+const { html } = compileScene({ polygons, cols: 80, rows: 24 }); // pure, no DOM
+```
+
+## Options (query params / CLI flags / `CompileFileOptions`)
+
+| Option | Query / flag | Default (library) |
+|---|---|---|
+| Camera angle | `rotX` `rotY` / `--rot-x` `--rot-y` | 65 / 45 |
+| Zoom | `zoom` / `--zoom` | 0.3 |
+| Projection | `projection=orthographic` / `--ortho` | perspective |
+| Grid | `cols` `rows` `cellAspect` / `--cols` … | 80 / 24 / 2.0 |
+| Render mode | `mode` / `--mode` | solid |
+| Palette | `palette` / `--palette` | default |
+| Colors | `colors=0` / `--no-colors` | on |
+| Recenter mesh | `autoCenter=1` / `--auto-center` | off |
+| Mesh optimize | `meshResolution` / `--mesh-resolution` | lossy |
+
+> Defaults are the **library** defaults (`createGlyphScene`). A loaded mesh is
+> not recentered or auto-fit unless you ask — pass `autoCenter` + a camera/zoom
+> to frame a model, the same as `<glyph-mesh>` in the runtime.
+
+## Interactive export
+
+Declare the interactions you want; only those ship. The manifest drives both the
+wired control (the snippet imports just that one) and the decimation budget
+(coarser for orbit, finer when `zoom`/`fpv` let the camera get close):
+
+```sh
+glyphcss dog.glb --interactions orbit,zoom --auto-center --full -o dog.html
+```
+
+```ts
+import { compileInteractive, toCodepenPrefill } from "@glyphcss/compile";
+
+const r = await compileInteractive("dog.glb", { interactions: ["orbit", "zoom"], autoCenter: true });
+r.html;            // self-contained: <div> + <script type=module> (glyphcss from CDN, mesh inlined)
+r.polygonCount;    // triangles shipped after decimation (vs r.sourcePolygonCount)
+toCodepenPrefill(r); // → { action, data } to POST a new CodePen
+```
+
+The pure, browser-safe builder is `buildGlyphInteractiveExport(polygons, opts)` in
+`glyphcss` — the gallery's "CodePen" button calls it directly on the loaded mesh.
+
+| `interactions` | Ships |
+|---|---|
+| `[]` | static scene, no control |
+| `["orbit"]` | orbit control, coarse decimation |
+| `["orbit","zoom"]` | + wheel zoom, finer decimation |
+| `["pan","zoom"]` | map controls |
+| `["fpv"]` | first-person controls, finest decimation |
+
+## Notes
+
+- **Textures**: the CLI / Node API decode PNG/JPG and bake each face to its
+  sampled color, so external (OBJ + `.mtl`) textures render in **true color** in
+  the terminal. GLB-embedded textures fall back to material/vertex colors. The
+  pure `compileScene` stays DOM-free — decoding lives in `loadMeshFromFile`.

package/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: glyphcss
+description: Render a 3D mesh, a primitive shape (cube, sphere, icosahedron, torus, cone…), or custom polygons to ASCII art — in the terminal (truecolor ANSI) or as HTML. Use when asked to render, preview, or visualize a 3D model or shape as text/ASCII.
+---
+
+# glyphcss — render 3D to ASCII
+
+`glyphcss` is a CLI that compiles 3D geometry to ASCII and prints it. In a
+terminal it defaults to **truecolor ANSI**, so the output shows in color directly.
+
+Install once: `npm i -g @glyphcss/compile` (the command is `glyphcss`). Or run ad
+hoc with `npx @glyphcss/compile <args>`.
+
+## Render a primitive shape
+
+```sh
+glyphcss cube --auto-center            # color ASCII cube in the terminal
+glyphcss sphere --auto-center
+glyphcss icosahedron --rot-x 60 --rot-y 30 --auto-center
+```
+
+A bare name with no file extension is treated as a shape. Available shapes:
+`tetrahedron cube octahedron dodecahedron icosahedron sphere cylinder cone torus
+pyramid prism antiprism bipyramid trapezohedron cuboctahedron icosidodecahedron`
+and the Archimedean/Catalan/Kepler-Poinsot solids (truncated*, snub*, rhombic*,
+triakis*, deltoidal*, great*/small* …).
+
+## Render a mesh file
+
+```sh
+glyphcss model.obj --auto-center       # .obj/.glb/.gltf/.vox/.stl
+glyphcss model.glb -f full -o out.html # write an HTML document
+```
+OBJ companion `.mtl` is auto-detected (or `--mtl FILE`); PNG/JPG textures are
+decoded and baked to per-face color.
+
+## Render custom polygons
+
+```sh
+glyphcss --polygons-json '[{"vertices":[[0,0,0],[2,0,0],[1,2,0]],"color":"#ff0000"}]'
+glyphcss --polygons shape.json --auto-center
+```
+JSON is an array (or `{ "polygons": [...] }`) of `{ vertices: [[x,y,z] ×3+], color?: "#rgb" }`.
+
+## Key options
+
+- **Output** `-f, --format` `ansi` | `text` | `html` | `full` (default: terminal→ansi, `-o` file→html, pipe→text)
+- **Frame** `--auto-center` recenters; with no `--cols`/`--rows` it auto-fits the grid to the content (or `--fit N` cols; give one of `--cols`/`--rows` and the other adapts)
+- **Camera** `--rot-x N` `--rot-y N` `--zoom N` `--ortho`
+- **Render** `--mode solid|wireframe|voxel` `--palette default|ascii|blocks|…` `--no-colors`
+- **Output to file** `-o FILE`
+- `glyphcss --help` lists everything.
+
+## Recipe: show a shape in the console
+
+```sh
+glyphcss cube --auto-center
+```
+That prints a centered, colored ASCII cube. Swap `cube` for any shape, a file, or
+`--polygons-json`. Use `-f text` for plain (no color), `-f full -o x.html` for a page.

package/dist/cli.cjs

@@ -0,0 +1,473 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_promises3 = require("fs/promises");
+
+// src/compileFile.ts
+var import_glyphcss = require("glyphcss");
+
+// src/loadMeshFromFile.ts
+var import_promises2 = require("fs/promises");
+var import_core = require("@glyphcss/core");
+
+// src/textureBakeNode.ts
+var import_promises = require("fs/promises");
+var import_pngjs = require("pngjs");
+var import_jpeg_js = __toESM(require("jpeg-js"), 1);
+function stripQuery(url) {
+  return url.split("?")[0].split("#")[0];
+}
+function toFilePath(url) {
+  const clean = stripQuery(url);
+  if (/^https?:\/\//i.test(clean)) {
+    try {
+      return decodeURIComponent(new URL(clean).pathname);
+    } catch {
+    }
+  }
+  if (clean.startsWith("file://")) {
+    try {
+      return decodeURIComponent(new URL(clean).pathname);
+    } catch {
+    }
+  }
+  return clean;
+}
+async function decode(path) {
+  const fp = toFilePath(path);
+  try {
+    const buf = await (0, import_promises.readFile)(fp);
+    if (/\.png$/i.test(fp)) {
+      const p = import_pngjs.PNG.sync.read(buf);
+      return { w: p.width, h: p.height, data: p.data };
+    }
+    if (/\.jpe?g$/i.test(fp)) {
+      const j = import_jpeg_js.default.decode(buf, { useTArray: true });
+      return { w: j.width, h: j.height, data: j.data };
+    }
+  } catch {
+  }
+  return null;
+}
+function texelAt(img, u, v) {
+  const x = Math.min(img.w - 1, Math.max(0, Math.round(u * (img.w - 1))));
+  const y = Math.min(img.h - 1, Math.max(0, Math.round((1 - v) * (img.h - 1))));
+  const i = (y * img.w + x) * 4;
+  return [img.data[i], img.data[i + 1], img.data[i + 2]];
+}
+function sampleFace(img, uvs) {
+  const pts = [uvs[0], uvs[1], uvs[2], [(uvs[0][0] + uvs[1][0] + uvs[2][0]) / 3, (uvs[0][1] + uvs[1][1] + uvs[2][1]) / 3]];
+  let r = 0, g = 0, b = 0;
+  for (const [u, v] of pts) {
+    const c = texelAt(img, u, v);
+    r += c[0];
+    g += c[1];
+    b += c[2];
+  }
+  const n = pts.length;
+  const h = (x) => Math.round(x / n).toString(16).padStart(2, "0");
+  return `#${h(r)}${h(g)}${h(b)}`;
+}
+async function bakeTexturesNode(polygons) {
+  const cache = /* @__PURE__ */ new Map();
+  const get = async (url) => {
+    if (!cache.has(url)) cache.set(url, await decode(url));
+    return cache.get(url) ?? null;
+  };
+  const out = [];
+  for (const p of polygons) {
+    const tt = p.textureTriangles?.[0];
+    const tex = p.texture ?? p.material?.texture ?? tt?.texture;
+    const uvs = tt?.uvs ?? (p.uvs && p.uvs.length >= 3 ? [p.uvs[0], p.uvs[1], p.uvs[2]] : void 0);
+    if (tex && uvs) {
+      const img = await get(tex);
+      if (img) {
+        out.push({ ...p, color: sampleFace(img, uvs), texture: void 0, textureTriangles: void 0, uvs: void 0 });
+        continue;
+      }
+    }
+    out.push(p);
+  }
+  return out;
+}
+function hasTextures(polygons) {
+  return polygons.some((p) => p.texture || p.material?.texture || p.textureTriangles?.[0]?.texture);
+}
+
+// src/loadMeshFromFile.ts
+function stripQuery2(url) {
+  return url.split("?")[0].split("#")[0];
+}
+async function siblingMtl(objPath) {
+  const clean = stripQuery2(objPath);
+  const dir = clean.replace(/[^/\\]+$/, "");
+  let candidate;
+  try {
+    const m = (await (0, import_promises2.readFile)(clean, "utf8")).match(/^\s*mtllib\s+(.+?)\s*$/im);
+    candidate = m ? dir + m[1].trim() : clean.replace(/\.obj$/i, ".mtl");
+  } catch {
+    candidate = clean.replace(/\.obj$/i, ".mtl");
+  }
+  try {
+    await (0, import_promises2.readFile)(candidate);
+    return candidate;
+  } catch {
+    return void 0;
+  }
+}
+async function fileFetch(url) {
+  const path = stripQuery2(url);
+  try {
+    const buf = await (0, import_promises2.readFile)(path);
+    const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    return {
+      ok: true,
+      status: 200,
+      text: async () => buf.toString("utf8"),
+      arrayBuffer: async () => ab
+    };
+  } catch {
+    return { ok: false, status: 404, text: async () => "", arrayBuffer: async () => new ArrayBuffer(0) };
+  }
+}
+async function loadMeshFromFile(path, options) {
+  const g = globalThis;
+  const prev = g.fetch;
+  g.fetch = fileFetch;
+  let result;
+  try {
+    const mtlUrl = options?.mtlUrl ?? (/\.obj(\?|$)/i.test(path) ? await siblingMtl(path) : void 0);
+    result = await (0, import_core.loadMesh)(path, { solidTextureSamples: false, ...options, mtlUrl });
+  } finally {
+    g.fetch = prev;
+  }
+  if (hasTextures(result.polygons)) {
+    return { ...result, polygons: await bakeTexturesNode(result.polygons) };
+  }
+  return result;
+}
+
+// src/compileFile.ts
+function worldMaxDim(polys) {
+  let mnx = Infinity, mxx = -Infinity, mny = Infinity, mxy = -Infinity, mnz = Infinity, mxz = -Infinity;
+  for (const p of polys) for (const v of p.vertices) {
+    if (v[0] < mnx) mnx = v[0];
+    if (v[0] > mxx) mxx = v[0];
+    if (v[1] < mny) mny = v[1];
+    if (v[1] > mxy) mxy = v[1];
+    if (v[2] < mnz) mnz = v[2];
+    if (v[2] > mxz) mxz = v[2];
+  }
+  if (!isFinite(mnx)) return 1;
+  return Math.max(mxx - mnx, mxy - mny, mxz - mnz, 1e-6);
+}
+function measureContent(inner) {
+  const lines = inner.replace(/<[^>]*>/g, "").split("\n");
+  let minC = Infinity, maxC = -1, minR = Infinity, maxR = -1;
+  lines.forEach((l, r) => {
+    for (let c = 0; c < l.length; c++) if (l[c] !== " ") {
+      if (c < minC) minC = c;
+      if (c > maxC) maxC = c;
+      if (r < minR) minR = r;
+      if (r > maxR) maxR = r;
+    }
+  });
+  return maxC < 0 ? { w: 0, h: 0 } : { w: maxC - minC + 1, h: maxR - minR + 1 };
+}
+function compilePolygons(polygons, options = {}) {
+  const buildCam = (zoom) => options.projection === "orthographic" ? (0, import_glyphcss.createGlyphOrthographicCamera)({ rotX: options.rotX, rotY: options.rotY, zoom }) : (0, import_glyphcss.createGlyphPerspectiveCamera)({ rotX: options.rotX, rotY: options.rotY, zoom, distance: options.distance, perspective: options.perspective });
+  const shared = {
+    autoCenter: options.autoCenter,
+    cellAspect: options.cellAspect,
+    mode: options.mode,
+    glyphPalette: options.glyphPalette,
+    useColors: options.useColors,
+    smoothShading: options.smoothShading,
+    creaseAngle: options.creaseAngle,
+    doubleSided: options.doubleSided,
+    supersample: options.supersample
+  };
+  if (options.autoFit && options.autoFit.target > 0) {
+    const { target, by } = options.autoFit;
+    const probeZoom = 40 / worldMaxDim(polygons);
+    const probe = (0, import_glyphcss.compileScene)({ polygons, camera: buildCam(probeZoom), cols: 200, rows: 120, ...shared, autoCenter: true });
+    const m = measureContent(probe.inner);
+    if (m.w > 0 && m.h > 0) {
+      const scale = by === "rows" ? target / m.h : target / m.w;
+      const zoom = probeZoom * scale;
+      const cols = Math.ceil(m.w * scale * 1.4) + 6;
+      const rows = Math.ceil(m.h * scale * 1.4) + 6;
+      const full = (0, import_glyphcss.compileScene)({ polygons, camera: buildCam(zoom), cols, rows, ...shared, autoCenter: true });
+      const inner = (0, import_glyphcss.cropGlyphInner)(full.inner);
+      const lines = inner.split("\n");
+      const w = lines.reduce((a, l) => Math.max(a, l.replace(/<[^>]*>/g, "").length), 0);
+      return { html: `<pre class="glyph-output">${inner}</pre>`, inner, cols: w, rows: lines.length, cellAspect: options.cellAspect ?? 2 };
+    }
+  }
+  return (0, import_glyphcss.compileScene)({
+    polygons,
+    camera: buildCam(options.zoom),
+    cols: options.cols,
+    rows: options.rows,
+    ...shared
+  });
+}
+async function compileFile(path, options = {}) {
+  const { polygons } = await loadMeshFromFile(path, { meshResolution: options.meshResolution, mtlUrl: options.mtlUrl });
+  return compilePolygons(polygons, options);
+}
+
+// src/compileInteractive.ts
+var import_glyphcss2 = require("glyphcss");
+async function compileInteractive(path, options = {}) {
+  const { polygons } = await loadMeshFromFile(path, { meshResolution: options.meshResolution, mtlUrl: options.mtlUrl });
+  return (0, import_glyphcss2.buildGlyphInteractiveExport)(polygons, options);
+}
+
+// src/cli.ts
+var import_glyphcss3 = require("glyphcss");
+var import_core2 = require("@glyphcss/core");
+var MESH_EXT = /\.(obj|glb|gltf|vox|stl)$/i;
+function normalizePolygons(data) {
+  const arr = Array.isArray(data) ? data : data?.polygons;
+  if (!Array.isArray(arr)) throw new Error("polygons JSON must be an array or { polygons: [...] }");
+  return arr.map((p, i) => {
+    const vertices = p.vertices ?? p.v;
+    if (!Array.isArray(vertices) || vertices.length < 3) throw new Error(`polygon ${i}: needs vertices [[x,y,z], \u2026] (>= 3)`);
+    return { vertices, color: p.color ?? p.c };
+  });
+}
+function parseArgs(argv) {
+  const opts = {};
+  let file;
+  let out;
+  let format;
+  let fit;
+  let shape;
+  let polygonsFile;
+  let polygonsJson;
+  let interactive = false;
+  let interactions;
+  let decimateGrid;
+  let cdnVersion;
+  const num = (v) => {
+    const n = Number(v);
+    return v !== void 0 && Number.isFinite(n) ? n : void 0;
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => argv[++i];
+    switch (a) {
+      case "--rot-x":
+        opts.rotX = num(next());
+        break;
+      case "--rot-y":
+        opts.rotY = num(next());
+        break;
+      case "--zoom":
+        opts.zoom = num(next());
+        break;
+      case "--distance":
+        opts.distance = num(next());
+        break;
+      case "--perspective":
+        opts.perspective = num(next());
+        break;
+      case "--cols":
+        opts.cols = num(next());
+        break;
+      case "--rows":
+        opts.rows = num(next());
+        break;
+      case "--cell-aspect":
+        opts.cellAspect = num(next());
+        break;
+      case "--crease-angle":
+        opts.creaseAngle = num(next());
+        break;
+      case "--supersample":
+        opts.supersample = num(next());
+        break;
+      case "--mode":
+        opts.mode = next();
+        break;
+      case "--palette":
+        opts.glyphPalette = next();
+        break;
+      case "--mesh-resolution":
+        opts.meshResolution = next();
+        break;
+      case "--mtl":
+        opts.mtlUrl = next();
+        break;
+      // Geometry input (instead of a mesh file).
+      case "--shape":
+        shape = next();
+        break;
+      case "--polygons":
+        polygonsFile = next();
+        break;
+      case "--polygons-json":
+        polygonsJson = next();
+        break;
+      case "--ortho":
+        opts.projection = "orthographic";
+        break;
+      case "--auto-center":
+        opts.autoCenter = true;
+        break;
+      case "--smooth":
+        opts.smoothShading = true;
+        break;
+      case "--double-sided":
+        opts.doubleSided = true;
+        break;
+      case "--fit":
+        fit = num(next());
+        break;
+      // Output format (+ back-compat aliases).
+      case "-f":
+      case "--format":
+        format = next();
+        break;
+      case "--ansi":
+        format = "ansi";
+        break;
+      case "--no-colors":
+      case "--text":
+        format = "text";
+        break;
+      case "--pre":
+      case "--html":
+        format = "html";
+        break;
+      case "--full":
+        format = "full";
+        break;
+      case "--interactive":
+        interactive = true;
+        break;
+      case "--interactions":
+        interactive = true;
+        interactions = (next() ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+        break;
+      case "--decimate-grid":
+        decimateGrid = num(next());
+        break;
+      case "--cdn-version":
+        cdnVersion = next();
+        break;
+      case "-o":
+      case "--out":
+        out = next();
+        break;
+      case "-h":
+      case "--help":
+        file = void 0;
+        return { file, out, format, fit, shape, polygonsFile, polygonsJson, interactive, interactions, decimateGrid, cdnVersion, opts };
+      default:
+        if (!a.startsWith("-") && !file) file = a;
+    }
+  }
+  return { file, out, format, fit, shape, polygonsFile, polygonsJson, interactive, interactions, decimateGrid, cdnVersion, opts };
+}
+var HELP = `glyphcss <mesh-file | shape> [options]
+
+  Input    a mesh file (.obj/.glb/.gltf/.vox/.stl), a primitive shape name
+           (e.g. cube, sphere, icosahedron, torus, cone), or:
+           --shape NAME   --polygons FILE.json   --polygons-json '[{"vertices":[...],"color":"#f00"}]'
+  Camera   --rot-x N  --rot-y N  --zoom N  --distance N  --perspective N  --ortho
+  Grid     --cols N  --rows N  --cell-aspect N   (omit cols/rows \u2192 auto-fit to content)
+  Fit      --fit N   target width in columns for auto-fit (default: terminal width or 80)
+  Render   --mode solid|wireframe|voxel  --palette NAME  --no-colors  --smooth  --double-sided
+  Mesh     --auto-center  --mtl FILE (OBJ material override)  --mesh-resolution lossy|lossless  --crease-angle N  --supersample N
+  Interact --interactive  --interactions orbit,zoom,pan,fpv  --decimate-grid N  --cdn-version V
+  Output   -f, --format text|ansi|html|full     (default: terminal \u2192 ansi, file \u2192 html, pipe \u2192 text)
+           -o, --out FILE
+`;
+function wrapHtml(inner) {
+  return `<!doctype html>
+<html><head><meta charset="utf-8"><title>glyphcss</title>
+<style>
+  html,body{margin:0;background:#0b0d10;color:#e2e8f0}
+  pre.glyph-output{margin:0;font:13px/1 ui-monospace,"SF Mono",Menlo,monospace;white-space:pre}
+</style></head>
+<body>${inner}</body></html>`;
+}
+async function main() {
+  const { file, out, format: fmtArg, fit, shape, polygonsFile, polygonsJson, interactive, interactions, decimateGrid, cdnVersion, opts } = parseArgs(process.argv.slice(2));
+  const positionalShape = file && !MESH_EXT.test(file) ? file : void 0;
+  const meshFile = file && MESH_EXT.test(file) ? file : void 0;
+  const shapeName = shape ?? positionalShape;
+  if (!meshFile && !shapeName && !polygonsFile && !polygonsJson) {
+    process.stderr.write(HELP);
+    process.exit(process.argv.length <= 2 ? 1 : 0);
+    return;
+  }
+  const format = fmtArg ?? (out ? "html" : process.stdout.isTTY ? "ansi" : "text");
+  if (interactive) {
+    if (!meshFile) throw new Error("--interactive needs a mesh file (shapes/polygons are static-only for now)");
+    const r = await compileInteractive(meshFile, { ...opts, interactions, decimateGrid, cdnVersion });
+    const output2 = format === "full" ? wrapHtml(r.html) : r.html;
+    if (out) {
+      await (0, import_promises3.writeFile)(out, output2, "utf8");
+      process.stderr.write(`glyphcss: wrote ${out} \u2014 interactive [${r.interactions.join(", ")}], ${r.polygonCount}/${r.sourcePolygonCount} tris
+`);
+    } else {
+      process.stdout.write(output2 + "\n");
+    }
+    return;
+  }
+  opts.useColors = format !== "text";
+  const hasCols = opts.cols !== void 0, hasRows = opts.rows !== void 0;
+  const termW = process.stdout.columns ? process.stdout.columns - 1 : 80;
+  if (fit !== void 0) opts.autoFit = { target: fit, by: "cols" };
+  else if (hasCols && !hasRows) opts.autoFit = { target: opts.cols, by: "cols" };
+  else if (hasRows && !hasCols) opts.autoFit = { target: opts.rows, by: "rows" };
+  else if (!hasCols && !hasRows) opts.autoFit = { target: termW, by: "cols" };
+  if (opts.autoFit) {
+    opts.cols = void 0;
+    opts.rows = void 0;
+  }
+  let result;
+  if (polygonsJson) result = compilePolygons(normalizePolygons(JSON.parse(polygonsJson)), opts);
+  else if (polygonsFile) result = compilePolygons(normalizePolygons(JSON.parse(await (0, import_promises3.readFile)(polygonsFile, "utf8"))), opts);
+  else if (shapeName) result = compilePolygons((0, import_core2.resolveGeometry)(shapeName, { size: 1 }), { ...opts, autoCenter: true });
+  else result = await compileFile(meshFile, opts);
+  const output = format === "text" ? result.inner : format === "ansi" ? (0, import_glyphcss3.encodeGlyphAnsi)(result.inner) : format === "full" ? wrapHtml(result.html) : result.html;
+  if (out) {
+    await (0, import_promises3.writeFile)(out, output, "utf8");
+    process.stderr.write(`glyphcss: wrote ${out} (${result.cols}\xD7${result.rows}, ${format})
+`);
+  } else {
+    process.stdout.write(output + "\n");
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`glyphcss: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node