arch-line-weights

Apply architectural line-weight hierarchy, optional solid-black poché, and material hatching to Rhino-exported .ai or .pdf drawings.

If you've ever exported a section, plan, or elevation from Rhino and watched all 340,000 strokes come out at a uniform 1.0 pt — and then tried to fix it inside Illustrator only to have ExtendScript hang for hours — this is for you.

What it does

• Inspects exported .ai/.pdf drawings and reports stroke-color counts.
• Rewrites stroke widths from a preset or hand-edited color mapping.
• Preserves layers when you use apply-jsx or apply-saas; the fast legacy apply command rewrites the PDF stream and can flatten Illustrator layers.
• Adds conservative poché fills for high-confidence section-cut mass.
• Ships explicit presets for section, plan, elevation, detail, and studio workflows.

$ arch-lw apply examples/sample-linework.pdf --auto --preset section
# 12 colors mapped using auto:section
applied 8,420 strokes across 12 color changes
wrote examples/sample-linework HIERARCHY.pdf

Runtime depends on drawing size, file format, and whether Illustrator-backed layer-preserving commands are used. Examples are workflow orientation only and are not public proof clearance.

---

Install

Current source install:

git clone https://github.com/zohartito/arch-line-weights
cd arch-line-weights
python -m venv .venv
.venv/bin/python -m pip install -e ".[test]"
.venv/bin/arch-lw --help

The [test] extra pulls in PyYAML, which the test/proof suite needs; without it the 15 proof tests fail with "PyYAML is required".

Optional global install if pipx is available:

pipx install git+https://github.com/zohartito/arch-line-weights

This installs the arch-lw CLI. Do not assume arch-lw, uv, or uvx are globally on PATH in a fresh studio shell; use .venv/bin/arch-lw from a source checkout or install with pipx.

To wire up the Claude Code skill:

ln -s "$(pwd)/skills/apply-arch-hierarchy" ~/.claude/skills/apply-arch-hierarchy

After the symlink, ask Claude Code to "apply line weights to my section" and the skill will fire.

---

Usage

Inspect first

Always look at the color distribution before applying. Most Rhino-export files have ~10–50 unique stroke colors, one per Rhino layer:

arch-lw inspect drawing.ai > inspect.json

The JSON contains every stroke RGB and how many strokes use it. The dominant colors (highest counts) are almost always material hatch / texture — they should land in the lightest tier.

Put a Rhino export on a sheet

If a Rhino Make2D export opens off the Illustrator artboard, normalize the layout before running hierarchy or poché. In Rhino, first select the Make2D curves and run:

_-RunPythonScript "/path/to/integrations/rhino/export_selected_make2d_manifest.py"

That writes an .ai / .pdf export plus a .manifest.json sidecar. Then run:

arch-lw layout-jsx rhino-make2d.ai \
  --artboard 24x36in \
  --fit fit \
  --margin 0.5in \
  --report-json layout-report.json

This opens the export in Illustrator, sets the requested artboard size, centers or fits visible unlocked artwork, saves <src> LAYOUT-jsx.ai, and writes a layout report. Use --dry-run --jsx-path layout.jsx to inspect the generated script without contacting Illustrator or writing output artwork.

For a single report that chains layout with optional hierarchy and poché:

arch-lw bridge-rhino-ai \
  --input rhino-make2d.ai \
  --artboard 24x36in \
  --fit fit \
  --margin 0.5in \
  --preset studio \
  --source rhino \
  --for-print \
  --apply-jsx \
  --poche \
  --report-dir proof

Layout success is not launch proof. The proof gate still depends on the verification reports and visual QA acceptance.

Two apply modes — pick by what you need

Mode	Speed	Layers	Use when
apply-jsx (default for .ai)	3–15 min on 340K paths	preserves the original Rhino layers as Illustrator layers	You'll keep editing the file in Illustrator (almost always the right choice for studio work).
apply	~2 min on 340K paths	flattens to 1 layer (PieceInfo gets stripped)	You only need a final render and don't care about layer structure.

# Layer-preserving (recommended for Rhino-export .ai files):
arch-lw apply-jsx drawing.ai

# pikepdf-fast (loses layer structure):
arch-lw apply drawing.ai --auto --preset studio

Day-1 layer-preserving dogfood path:

.venv/bin/arch-lw inspect drawing.ai
.venv/bin/arch-lw apply-saas drawing.ai \
  --architectural --poche --preset studio --source rhino

Use basic apply for fast stroke-weight output. Use apply-saas --architectural --poche when Cursor 1 needs layer-preserving hierarchy plus conservative black poché for Illustrator/Acrobat inspection.

Input caveats for that path:

• apply-saas --poche requires a native Illustrator .ai with /NumBlock.
• PDF-only or [Converted] .ai files use apply-jsx, then arch-lw poche on the HIERARCHY-jsx output.
• Legacy Rhino PostScript .ai exports may need Illustrator File > Save As / re-save before v1 can process them.

Supported input matrix:

This is the beginning of the README. Read the rest at the original. Read the full README ↗