A single filesystem transformation in a molt plan. Paths are relative to the repo root.

Applies a verified plan at root. Callers must run verify and conflicts first — apply assumes anchors match, targets exist, and nothing is in the way of created files.

What stands between a printed plan and applying it, given the run mode.

A terminal always gets a confirm prompt — the wizard's answers were just typed, and one keystroke catches a typo'd name before it hits disk. The one combination with no gate at all is --wetrun on a clean tree without a terminal — there git reset --hard && git clean -fd restores the pre-molt state (the tree was clean, so git clean removes only files molt created). A dirty tree (reachable only via --force) never applies without the dirty-specific in-the-moment confirmation, and without a terminal it never applies at all: "commit first" is always available, so an override flag would just recreate the hole.

Builds the full molt plan from resolved choices. Pure — reads nothing.

Strips any feature whose requires parent is stripped.

Verifies the plans for both sample configs, covering every anchor molt can touch (each feature exercised kept in one config and stripped in the other), plus the embedded-template invariants that anchors alone can't see.

What check_all found, split by remedy.

Errors surfaced by molt.

Exit-code dialect: 0 success; 2 = the caller must change something local (arguments, git state, modified files) before retrying; 1 = everything else.

Lists the files the plan creates that already exist at root, kept apart from verify's drift because the remedy differs.

The non-interactive refusal to keep docs without a repository url.

Kept features whose required members are all stripped — invalid combinations the caller must reject (or repair by stripping the parent too). Registry order, so callers report deterministically.

A molt-selectable feature of the template.

Runs a git command at root, returning its stdout on success and null on a nonzero exit (e.g. no origin remote configured). Clears the INHERITED_GIT_ENV variables so git always resolves the repo from root.

Escapes a string for embedding in a JSON string literal (also valid for TOML basic strings, which share the \"/\\/\n escapes).

The ranges of the lines in content that start with prefix, each including its trailing newline when it has one.

The features that provide required members for parent.

Fully-resolved molt choices, assembled from flags and wizard answers. kept holds the feature ids (from FEATURES) to keep.

Normalizes the git origin url with to_repo_url, returning null for the template's own remote (a plain git clone of fuz_template keeps origin pointed at the template — deriving that would be wrong). GitHub owner and repo names are case-insensitive, so the check is too.

Splits repeatable/CSV flag values into feature ids, validating each.

Like parse_repo_url, but blank input (after trim_url) is no url.

Parses a repository url given as a flag or wizard answer into its web url via to_repo_url, so an ssh remote pasted as-is still yields working source links in the API docs.

Parses argv into the flag struct, or null when --help was printed.

Substitutes __PLACEHOLDER__ tokens in a template.

Single-pass over the template: inserted values are never re-scanned, so user-provided text (a description containing __RUST_SECTION__, say) can't corrupt the output.

Resolves the kept-feature set from --keep/--strip flags, applying defaults and the requires cascade. explicit returns which features the flags decided (the wizard prompts only for the rest).

Two configs that together exercise every plan branch: one keeps every registry feature (derived from FEATURES, so a new feature is covered without touching this) and sets every optional value, one strips every feature and clears the optional values.

The output templates from crates/molt/templates/, substituted with __PLACEHOLDER__ tokens. The Rust twin embeds these at compile time; here they're read from the working tree (always present pre-molt).

Converts a repository url in any common git form (https or http, scp-style git@host:, or ssh://git@host/) to its web url — the ssh forms become https without their ssh port, userinfo (a user or token) is dropped, the scheme is lowercased, an empty port is dropped, a ?query or #fragment is dropped from the ssh:// and http(s) forms (the scp form keeps ?/# as literal path characters), and a trailing / or .git is dropped — returning null for anything else (a local path, a bare owner/repo, an empty host).

Trims whitespace and byte-order marks from a url, matching the Rust twin's trim_url (JS's \s covers U+FEFF but not U+0085, Rust's is_whitespace the reverse, so each twin adds the other's).

Validates a project description: a single line, no control characters (it lands in package.json, TOML, and markdown blockquotes).

Validates a bare domain like example.com (no scheme, no path).

Validates a project name: snake_case, usable as a crate name.

Validates an npm package name (scoped names like @you/name allowed): lowercase url-safe characters, no ./_ prefix, npm's 214-char limit.

Verifies every action's preconditions against the tree at root, returning human-readable issues (empty = the plan is applicable).