// ZSHRS — C-TO-RUST PORT COVERAGE REPORT

>_EXECUTIVE SUMMARY

Large-scale C-to-Rust port of upstream zsh: strict-port code under src/ported/ plus non-port extensions. The core file table below is regenerated from the same indexer as port_report.html (regex C top-level defs + Rust fn names + port-doc mining). Those counts are a mechanical index, not proof that every path is behavior-complete.

Codebase split (NEW): the runtime crate now physically isolates ported code from non-port code so drift is mechanically detectable. src/ported/ (107 files) is the strict-port directory — every .rs mirrors a real src/zsh/Src/<x>.c file, every top-level fn carries a /// Port of <cname>() from Src/<file>.c:NNNN doc-comment, and the file set is FROZEN (no new files; PORT.md §"ABSOLUTE FREEZE"). src/extensions/ (40 files) is the non-port directory — features zsh C does not have (AOT, daemon coordination, plugin/script/autoload caches, fish-style autosuggest/abbrev/highlight, persistent worker pools, ZWC byte-code helpers). src/recorder/ (1 file) is feature-gated; deleted by rustc in the default build. Both invariants are enforced by tests/port_purity.rs — a regression of either rule fails CI.

Scope note: this report covers the C-to-Rust port (i.e. src/ported/ only) — what was translated from upstream zsh. It does not cover the new Rust infrastructure layered on top (zshrs-daemon singleton, zshrs-recorder AOP intercept, IPC + HTTP + OpenAPI surface, canonical-state rkyv shards, the z* builtin family, session-persistent supervised jobs with bidirectional ptmx attach, the parser surface in src/ported/parse.rs). That work has no C ancestor and is reported separately in daemon-report.html. See “BEYOND THE C PORT” section below for the cross-link.

#FILE-BY-FILE COVERAGE

Per-file columns: C Fns = symbols whose primary C definition is that file (unique name, heuristic indexer). Same-name Rust fn = a Rust definition with the identical identifier. Other rows = the remainder (doc-only pointers, different Rust names, or not yet indexed). Port-index % = ported / total from gen_port_report.py (ported = any Rust hit or port-doc mention). Rust targets: src/ported/<stem>.rs except exec.c → src/exec.rs.

&RENAMING PATTERNS

C uses free functions with global state. Rust uses struct methods, enum variants, and pattern matching. Every “renamed” C function maps to a Rust equivalent under an idiomatic name. This section explains the mapping patterns.

$KEY FEATURES PORTED

@PER-SYMBOL PORT INDEX

Hand-maintained per-function tables previously claimed a fixed “859” row total and drifted (wrong Rust paths, inflated coverage). Those rows are removed. The port_report.html file produced by python3 scripts/gen_port_report.py lists every C symbol the indexer extracts from src/zsh/Src/**/*.c (heuristic: top-level ident( with a following {) together with Rust placement and port-doc pointers — regenerate after upstream or port changes.

The core file table above (between PORT_REPORT:CORETABLE markers) is rewritten by the same script from live tree counts; it is not manually curated.

!TEST RESULTS

Pass/fail counts are intentionally not pinned in this HTML snapshot (they drift with feature flags and cargo version). The static surface is the #[test] hook total in the engineering overview below. For a local matrix run cargo test with the same features you ship; when triaging ordering-sensitive cases, --test-threads=1 remains the tie-breaker.

~ARCHITECTURE: WHY RUST IS DIFFERENT

%ENGINEERING OVERVIEW

Workspace-wide cargo workspace metrics (three packages: zshrs, compsys, zshrs-daemon). Counts below are from wc / rg on 2026-05-23; per-subsystem module tables follow unchanged.

ΔMAY 2026 — RECENT PORT WORK

Three themes closed out across May 2026: (1) every // Deferred / // FAKE / // stub marker in builtin.rs turned into a real C-faithful body, (2) the try_with_executor dispatch path — a Rust-only abstraction that bypassed paramtab — was eliminated entirely from src/ported/ (40 → 0 call sites; only two historical comments remain in subst.rs), and (3) all 30 module files (clone/cap/example/datetime/socket/tcp/stat/zftp/zprof/zselect/watch/zpty/termcap/terminfo/attr/system/zutil/ksh93/db_gdbm/pcre/param_private/mathfunc/langinfo/hlgroup/mapfile/parameter/nearcolor/random/regex/files) were migrated from per-module featuresarray/handlefeatures/getfeatureenables/setfeatureenables stub copies to the canonical crate::ported::module::* impls — 4 stubs × 30 modules = 120 duplicate fake fns deleted, replaced with slice-based module::Features { bn_list, cd_list, mf_list, pd_list } arrays populated with the real BUILTIN/CONDDEF/MATHFUNC/PARAMDEF entries.

Other major de-faking in May: fake structs in hashtable.rs deleted (CmdName / Alias / Reswd / DirCache / SuffixAliasTable / ReswdToken / ShFunc impl block — all replaced with canonical lowercase C-named structs from zsh_h.rs), jobs.rs deleted (JobEntry / BgStatus / PipeStats / CommandTimer / JobPointers fake aggregates; JobState/JobInfo/JobTable moved out to exec_jobs.rs), input.rs deleted (StringInput convenience wrapper, InputBuffer aggregate, INP_* drift constants), glob.rs deleted (GlobOptions / GlobSort / SortOrder / SortSpec / TimeUnit / SizeUnit / RangeOp / impl GlobMatch), cond.rs deleted (CondType / CondResult / CondEval fake enums), module.rs deleted (Wrapper struct + addwrapper/deletewrapper), options.rs deleted (ShellOption enum, with opt_state_get("name") globally swapped to isset(OPT_CONST)).

try_with_executor migration: complete. 0 call sites remain in src/ported/ (down from 40). The two surviving mentions are documentation comments in subst.rs:169 and subst.rs:496 referencing the historical removal — no live dispatch path through the fake-executor abstraction.

*MODULE BREAKDOWN BY SUBSYSTEM

+35 LOADABLE MODULE PORTS

Each C module from src/zsh/Src/Modules/ has a corresponding strict-port Rust implementation in src/ported/modules/. Module file set is included in the file freeze on src/ported/; every module now routes its features_ / enables_ / cleanup_ hooks through the canonical module::featuresarray / handlefeatures / setfeatureenables impls instead of per-module Rust-only stub copies.

^ZLE LINE EDITOR — 28 FILES, 35,670 LINES

The Zsh Line Editor (ZLE) is a complete terminal-based input system with vi and emacs keybinding modes, programmable widgets, and inline completion. Ported from src/zsh/Src/Zle/*.c. Files mirror the C source 1:1 with the canonical zsh prefix (zle_* / comp* / termquery / deltochar).

;145 SHELL BUILTINS

Every zsh builtin is implemented as a builtin_* method on ShellExecutor in exec.rs. This includes all POSIX builtins, all zsh extensions, all loadable module builtins, and file operation builtins.

&DEPENDENCY ARCHITECTURE

                         ┌──────────────────────────────────────┐
                         │            exec.rs (22,994)          │
                         │     ShellExecutor + 145 builtins     │
                         └──────────┬───────────────────────────┘
                                    │
               ┌────────────────────┼─────────────────────┐
               │                    │                     │
        ┌──────▼──────┐     ┌──────▼──────┐      ┌───────▼──────┐
        │  parser.rs   │     │  lexer.rs   │      │ subst_port.rs│
        │  (4,099)     │     │  (2,551)    │      │  (5,021)     │
        │  AST builder │     │  tokenizer  │      │  expansion   │
        └──────────────┘     └─────────────┘      └──────────────┘
               │                                          │
    ┌──────────┼──────────────────────────────────────────┤
    │          │          │          │          │          │
┌───▼───┐ ┌───▼───┐ ┌───▼───┐ ┌───▼───┐ ┌───▼───┐ ┌───▼────┐
│params │ │pattern│ │ glob  │ │ hist  │ │ math  │ │  text  │
│(3,630)│ │(1,581)│ │(2,501)│ │(1,825)│ │(1,714)│ │  (980) │
└───┬───┘ └───────┘ └───────┘ └───┬───┘ └───────┘ └────────┘
    │                             │
┌───▼───┐ ┌───────┐ ┌───────┐ ┌──▼────┐ ┌────────┐ ┌───────┐
│ utils │ │ jobs  │ │signals│ │prompt │ │  init  │ │options│
│(3,204)│ │(1,667)│ │(1,117)│ │(1,552)│ │  (598) │ │ (877) │
└───────┘ └───────┘ └───────┘ └───────┘ └────────┘ └───────┘
               │
    ┌──────────┼──────────────────────────┐
    │          │          │               │
┌───▼───┐ ┌───▼───┐ ┌───▼───┐    ┌──────▼──────┐
│  zwc  │ │  zle/ │ │  cond │    │  20 modules │
│(1,577)│ │(8,227)│ │  (818)│    │  (16,149)   │
└───────┘ └───────┘ └───────┘    └─────────────┘

◆COMPSYS — ZSH COMPLETION SYSTEM IN RUST

A standalone Rust crate reimplementing zsh’s compsys — the programmable completion system. 27 modules, 23,319 lines, 154 public functions. Replaces 24,000+ lines of zsh shell functions with compiled Rust backed by Rkyv caching.

// 70 COMPLETION FUNCTIONS

⬢FUSEVM + LEX / PARSE (src/ported/)

Runtime bytecode targets the crates.io fusevm crate (pinned in workspace Cargo.toml). Lexing and parsing live in src/ported/lex.rs and src/ported/parse.rs in the runtime crate (the standalone parse package was absorbed back). Stryke / strykelang is a separate repository — it is not part of this workspace; the former Perl-interpreter block here was erroneous pasted content.

// LEX + PARSER (IN-CRATE PORTS)

// EXECUTION PIPELINE (ZSHRS)

  Source / REPL input (zsh script)
       │
       ▼
  ┌─────────────────┐     ┌──────────────────┐
  │  Lexer          │────▶│  Parser          │
  │  (lex.rs)       │     │  (parse.rs)      │
  │  token stream   │     │  AST / commands  │
  └────────┬────────┘     └────────┬─────────┘
           │                       │
           └───────────┬───────────┘
                       ▼
              ┌────────────────────┐
              │ compile_zsh (+AOT) │  ──▶  fusevm bytecode (workspace crate)
              │ extensions/        │
              └─────────┬──────────┘
                        ▼
              ┌────────────────────┐
              │ ShellExecutor / VM │  ──▶  builtins, jobs, redirects, zle
              └────────────────────┘

●BEYOND THE C PORT — RUNTIME INFRASTRUCTURE

The C-to-Rust port covered above lives under src/ported/ against upstream src/zsh/Src/**/*.c. The numbers below count what zshrs adds — new Rust code with no C ancestor. This is the layer that takes zshrs from “zsh in Rust” to “the first compiled Unix shell with a session-persistent daemon, AOP-intercept recorder, and bidirectional ptmx-attach job supervisor.” Non-port runtime code lives in src/extensions/ — mechanically isolated from src/ported/ by tests/port_purity.rs.

Architectural moves with no zsh equivalent: the 90/10 daemon/shell work split (singleton daemon owns every mutation; thin shell clients are stateless and forkable); the recorder-owns-rebuild stance (no in-daemon walker; zshrs-recorder is the sole producer of recorder-managed canonical subsystems); the single ~/.zshrs/ directory rule (every config + log + sqlite + rkyv shard + socket under one root, configurable via $ZSHRS_HOME); the z* builtin family (zcache / zls / zsend / znotify / zsubscribe / zjob / zsync / zask / zlock / zpublish / zwhere / zd); session-persistent supervised jobs with bidirectional ptmx attach (replaces nohup + screen + pueue + disown); the auto-derived OpenAPI 3.1 surface at GET /openapi from the daemon op registry; the flat zsh-extended-history text file + sibling FTS5 sqlite index; zsh grammar introspection to stdout (lexer token stream, Eprog wordcode layout, parser AST S-expression) via zshrs --dump-* and zshrs_dump (dumptokens, dumpwordcode) in formats byte-diffable against parity harnesses — not shipped as a trio by stock zsh. Full list + governance in CREATORS.md; op-by-op detail in daemon-report.html.

≡GRAND TOTAL — FULL WORKSPACE

Two Rust packages in one Cargo workspace (zshrs + zshrs-daemon; compsys was folded into zshrs). Combined: 651,206 Rust lines (git ls-files '*.rs' | xargs wc -l), 5,483 pub fn lines (git ls-files '*.rs' | xargs rg '^\s*pub fn '), 580 pub struct, 126 pub enum, 14,638 #[test] lines (git ls-files '*.rs' | xargs rg '^\s*#\[test\]') — each rg over the same tracked .rs set as wc, 2026-05-27.