How to nested extractor in developer workflows
- Step 1Open on a Pro account — Go to /archive-tools/nested-archive-extractor. Minimum tier is Pro — free accounts get an upgrade overlay. This is a UI tool, not an API call (see the automation step).
- Step 2Drop the artifact — Drag one archive in: a release ZIP, a
.jar/.war(ZIP under the hood), anode_modules.tar.gz, or a vendor bundle. Single file only. - Step 3Choose depth by intent — Quick structure peek: maxDepth 1-2. Full dependency unpack: 3-5. Default 3. The output paths show every layer, so even a shallow run reveals the nesting shape.
- Step 4Process and inspect — Click Process. Read Archives unpacked and Entries to confirm the depth was enough — if an inner archive shows up as a leaf in the output, you hit the depth limit and should raise it.
- Step 5Download the flattened ZIP — Save
<artifact>-flattened.zip. Each file sits at its full nested path. Run it through file-listing-generator for a dependency CSV, or path-prefix-remover to strip the outer prefix. - Step 6For CI, use the CLI equivalent — There is no public API for archive tools. In a pipeline, replicate the behaviour with a guarded recursive
unzip/7z x/tar xzfloop (see the cookbook), or run on a Pro+ tier through the headless-browser runner for ad-hoc jobs.
Developer artifacts that nest
Common nested artifacts and the depth that flattens them. JAR/WAR/EAR are ZIPs, so they recurse like any ZIP.
| Artifact | Nesting | maxDepth | Flattened sample path |
|---|---|---|---|
| Spring Boot fat JAR | app.jar (zip) → BOOT-INF/lib/*.jar | 2-3 | app.jar/BOOT-INF/lib/dep.jar/... |
| npm release bundle | release.zip → pkg.tgz → package/* | 3 | pkg.tgz/package/index.js |
| Vendored deps tarball | deps.tar.gz → vendor/*.tar.gz | 3-4 | vendor/lib.tar.gz/include/x.h |
| CI logs bundle | logs.zip → step-*.gz | 2 | step-build.gz/build.log |
| Mixed vendor drop | drop.zip → sdk.7z + samples.zip | 3 | sdk.7z/* and samples.zip/* |
Capabilities and honest limits for automation
What the tool does and does not do for a developer pipeline. Verified against the schema and processor.
| Aspect | Reality |
|---|---|
| Public API | None — archive tools are browser-only (apiAvailable: false) |
| Runner mode | Pro+ tiers can run via a headless-browser runner, not a documented endpoint |
| Input count | Single file (no batch, no folder) |
| Options | Only maxDepth (number, default 3, min 1, max 10) |
| Output format | Always ZIP, DEFLATE level 6 — never a true 7z/rar |
| Reproducibility | Same input + same maxDepth ⇒ same flattened layout; no timestamp normalisation here |
| Failure mode | Bad/encrypted member preserved as raw bytes; job does not abort |
Cookbook
Nested developer artifacts and the flattened result, plus the CLI loop that mirrors the tool for CI.
Flatten a Spring Boot fat JAR
A JAR is a ZIP; nested dependency JARs live under BOOT-INF/lib. Depth 3 surfaces every library's contents.
Input: app.jar (ZIP) BOOT-INF/lib/dep-a.jar BOOT-INF/lib/dep-b.jar maxDepth: 3 Output: app-flattened.zip BOOT-INF/lib/dep-a.jar/com/x/A.class BOOT-INF/lib/dep-b.jar/com/y/B.class (use file-listing-generator on the output for a class inventory)
npm release bundle to a flat tree
A release ZIP wrapping a packed tgz. The tgz opens as gz then tar across two layers.
Input: release.zip my-pkg-1.4.0.tgz -> package/index.js, package/package.json maxDepth: 3 Output: release-flattened.zip my-pkg-1.4.0.tgz/package/index.js my-pkg-1.4.0.tgz/package/package.json
Depth peek before a full unpack
Run shallow to learn the structure, then deep. Inner archives appear as leaves when depth is too low.
maxDepth: 1 Output: drop-flattened.zip sdk.7z <- leaf (not yet recursed) samples.zip <- leaf => structure learned; rerun with maxDepth: 3 to unpack both.
CI equivalent: guarded recursive loop
There is no API, so a pipeline replicates the behaviour with a loop. Note per-format dispatch and the depth guard you add yourself.
# CI step: flatten nested artifacts (no JAD API)
DEPTH=3
flatten() {
[ "$2" -gt "$DEPTH" ] && return
for f in "$1"/*.zip "$1"/*.7z "$1"/*.tar.gz; do
[ -e "$f" ] || continue
d="${f}.d"; mkdir -p "$d"
case "$f" in
*.zip) unzip -oq "$f" -d "$d" || continue;;
*.7z) 7z x -y "$f" -o"$d" >/dev/null || continue;;
*.tar.gz) tar xzf "$f" -C "$d" || continue;;
esac
flatten "$d" $(( $2 + 1 ))
done
}
flatten ./artifact 1Reproducible manifest from the flattened output
Feed the deterministic flattened ZIP into checksums for a supply-chain attestation record.
app-flattened.zip -> checksum-generator (SHA-256) BOOT-INF/lib/dep-a.jar/com/x/A.class e3b0c44298... BOOT-INF/lib/dep-b.jar/com/y/B.class 2c26b46b68... (commit alongside the build provenance)
Edge cases and what actually happens
Expecting a public API
Not availableArchive tools have no public API (apiAvailable: false) because they depend on browser WASM. Pro+ tiers can run them via a headless-browser runner, but there is no documented HTTP endpoint. For CI, use the guarded recursive loop in the cookbook.
Want a true 7z artifact out
ZIP onlyThe tool always emits a flattened ZIP (DEFLATE level 6). It reads nested 7z/rar via libarchive but never writes them. If your pipeline needs a 7z/rar artifact, use the native binaries after flattening.
Need to flatten many artifacts in one run
Single fileThis tool takes one input file. For many at once, use batch-extraction-manager for a flat batch extract, or loop the artifacts through this tool individually. There is no folder picker for this slug.
Inner archive not recursed
Depth or extensionAn inner archive appears as a leaf in the output when either maxDepth was reached or its name lacks a known archive extension. Raise depth, or rename the member to a recognised extension before running.
Expecting timestamp normalisation
Not appliedThis tool does not normalise entry timestamps — the output ZIP carries whatever the recursion produced. Reproducibility here means the same layout and file bytes, not byte-identical ZIP headers. For zeroed timestamps, post-process with timestamp-normalizer.
Encrypted nested dependency
Preserved (raw)No password option exists, so an encrypted member is preserved as raw bytes rather than unpacked. Decrypt it first with multi-format-extractor, then re-run nesting.
Output entry count exceeds tier cap
Limit reachedA deep dependency tree can flatten to tens of thousands of class files. Pro caps at 50,000 entries, Pro-media/Developer at 500,000. Lower maxDepth or flatten a sub-archive if you hit it.
Artifact over the size cap
Rejected (limit)Inputs over the tier byte cap (Pro 500 MB, Pro-media/Developer 2 GB) are blocked before processing. Large monorepo artifacts may need the CLI loop instead.
Duplicate file names across nested JARs
Preserved (path-distinct)Each member is stored under its <archive>/... prefix, so dep-a.jar/META-INF/MANIFEST.MF and dep-b.jar/META-INF/MANIFEST.MF stay distinct — exactly what you want for a per-dependency view.
Frequently asked questions
Is there a CLI or API for this?
No public API — archive tools are browser-only (apiAvailable: false); Pro+ tiers run them through a headless-browser runner. For scripting and CI, replicate the behaviour with a guarded recursive unzip/7z x/tar xzf loop (see the cookbook example).
How do I make the output reproducible?
Given the same input and the same maxDepth, the flattened layout and file bytes are identical. This tool does not normalise ZIP timestamps, so headers may differ run to run — if you need byte-identical archives, post-process with timestamp-normalizer.
Can I script bulk nested-extractor runs?
Not through the JAD tool directly — there is no API and no batch input on this slug. Use the cookbook's recursive shell loop in CI, or run artifacts one at a time in the UI on a Pro+ account.
Does the output work with my build tooling?
The output is a standard ZIP (DEFLATE) readable by every unzip implementation. Note the path prefixing (<archive>/<inner>/<file>) — if your tooling expects a flat root, run path-prefix-remover afterwards.
Will it unpack nested JARs?
Yes — a JAR/WAR/EAR is a ZIP, and nested JARs (e.g. BOOT-INF/lib in a Spring Boot fat JAR) recurse like any ZIP. Set maxDepth to 2-3 to reach the libraries' contents.
Can it read a 7z or rar dependency?
It reads them via libarchive WASM, so the contents are extracted into the output ZIP. It does not write 7z/rar — output is always ZIP.
What is the only option I can change?
maxDepth — a number from 1 to 10, default 3. There are no other controls (no password, no format selector, no compression level) on this tool.
How do I get a dependency inventory?
Run the flattened ZIP through file-listing-generator for a CSV/JSON/TXT listing of every leaf and its full nested path. Combine with checksum-generator for a hashed manifest.
What happens if a vendored archive is corrupt?
It is preserved as raw bytes and the job continues — you still get every other dependency. The Archives-unpacked metric drops, flagging which layer failed.
Does it run offline?
Once the page and WASM modules have loaded, processing happens in-tab with no further network calls for your data. The initial page load needs a connection, and you need a Pro session.
Can I flatten a multi-gigabyte monorepo artifact?
Up to 2 GB on Pro-media/Developer (500 MB on Pro). Beyond that, or for CI, use the recursive CLI loop which is bounded only by disk and RAM.
Why does an inner archive show up unextracted in the output?
Two causes: you hit maxDepth (raise it, up to 10), or the member's name lacks a recognised archive extension so the recursion treated it as a leaf. Check the extension and the depth.
Privacy first
Every JAD Archive tool runs entirely in your browser using fflate, @zip.js/zip.js, and the libarchive WASM bridge. Your archives never leave your device — verified by zero outbound network requests during processing.