How to troubleshooting the selective zipper
- Step 1Read the result panel first — After Process, check
MatchedandTotal considered.Matched=0→ the glob caught nothing (you will also see theNo files matchederror).Total considered=0→ nothing was actually dropped. These two numbers diagnose most problems instantly. - Step 2Check whether you used `*` where you needed `**` — A single
*does not cross/(it compiles to[^/]*).src/*.tsonly matches files directly insrc/. If you meant 'any depth', usesrc/**/*.ts. - Step 3Account for the dropped folder's name — If you dropped a parent folder, every path starts with that folder's name (e.g.
project/src/app.ts). A pattern likesrc/**/*.tsthen matches nothing. Use**/*.tsto ignore the prefix, or prepend the folder name. - Step 4Stop using unsupported syntax — Braces (
*.{ts,tsx}), excludes (!*.test.ts), and character classes ([a-z]) are not supported — braces and brackets are treated as literals. Replace braces with multiple runs; replace excludes with the inverse workflow. - Step 5Confirm you are within the tier cap — The documented free cap is 50 MB / 500 entries; Pro is 500 MB / 50,000. Since the work runs in-tab via fflate, very large drops are also limited by browser memory. Drop a smaller folder (every dropped file is read into memory regardless of the glob) or upgrade your tier if a big job stalls.
- Step 6Confirm it is the right tool — Selective Zipper BUILDS a ZIP from local files. If you meant to extract from an existing archive, use selective-extractor; to zip a whole folder, folder-to-zip; to encrypt, encrypted-zip-creator.
Symptom → cause → fix
The fast path from what you see to what to change. All causes are local — there is no upload, WASM, or server step in this tool.
| Symptom | Likely cause | Fix |
|---|---|---|
No files matched pattern | Glob caught nothing (often a * vs ** or prefix issue) | Use ** to cross dirs; add/remove the folder-name prefix |
Drop files or a folder first. | Nothing was dropped (or an empty subfolder) | Re-drop the folder; verify files exist in it |
| Matched fewer than expected | Wrong extension or * not crossing / | Switch to **/*.ext; check the exact extension |
| Brace glob matches nothing | {a,b} is literal, not expanded | Run a pass per extension, merge with archive-merger |
| Can't exclude a file | No negative globs supported | Curate folder, or folder-to-zip + selective-extractor |
| Stalls / fails on a huge folder | Near tier cap or browser-memory ceiling | Drop a smaller folder or upgrade tier |
| Output is ZIP, not tar.gz | Tool writes ZIP only | Convert with zip-to-tar-gz / archive-format-converter |
| Timestamps all reset | Default entry timestamps, not source mtimes | Post-process with timestamp-normalizer |
What the Selective Zipper does NOT do (and where to go)
Misattributed capabilities, corrected. Each row points to the sibling tool that actually does the job.
| Misconception | Reality | Right tool |
|---|---|---|
| It encrypts the ZIP with a password | No encryption option — plain ZIP via fflate | encrypted-zip-creator |
| It reads/filters an existing archive | It builds a new ZIP from local files | selective-extractor |
| It can output tar.gz / gz / 7z | ZIP only (filtered.zip) | archive-format-converter |
| It supports brace/exclude globs | *, **, ? only — positive single pattern | Two runs + archive-merger |
| It lets me set compression level | Fixed DEFLATE level 6 | compression-level-optimizer |
| It preserves original modified times | Default entry timestamps | timestamp-normalizer |
Cookbook
Walkthroughs for each failure mode, showing the exact panel output and the one-line change that fixes it.
Fix: 'No files matched pattern'
The pattern looks right but uses a single * to cross directories. Switching to ** resolves it.
globPattern: src/*.ts -> No files matched pattern "src/*.ts" (reason: * does not cross /, files are in src/app/...) Fix: globPattern: src/**/*.ts -> Matched=3
Fix: dropped folder prefix
Dropping the parent folder added its name to every path, so the src/ prefix never matched.
Dropped 'myapp' -> paths are myapp/src/... globPattern: src/**/*.ts -> Matched=0 Fix (either works): globPattern: myapp/src/**/*.ts -> Matched=3 globPattern: **/*.ts -> Matched=3
Fix: brace glob caught nothing
Brace expansion is unsupported, so *.{ts,tsx} is searched literally. Split into two runs and merge.
globPattern: *.{ts,tsx} -> Matched=0 (literal {ts,tsx})
Fix:
Run 1: **/*.ts -> ts.zip
Run 2: **/*.tsx -> tsx.zip
archive-merger: ts.zip + tsx.zip -> all.zipFix: huge folder stalls the tab
A very large drop strains browser memory and may exceed your tier cap. The entry count (not just total size) matters because every dropped file is read into memory. Drop less, or split the job.
Dropped: build/ (1,200 files, 35 MB) Free tier cap: 500 entries / 50 MB Fix options: - Drop a narrower folder (build/js/ only) - Split into runs, merge with archive-merger - Upgrade to Pro (50,000 entries / 500 MB)
Fix: wrong tool entirely
You wanted to pull files OUT of an existing ZIP, but Selective Zipper builds a NEW ZIP from local files.
Goal: extract *.svg from assets.zip Wrong: Selective Zipper (it builds, not extracts) Right: selective-extractor input: assets.zip globPattern: *.svg -> extracts matching entries
Edge cases and what actually happens
Error: No files matched pattern
ErrorThrown when the glob catches zero files; the tool never emits an empty ZIP. Top causes: a single * used where ** is needed, a wrong extension, or the dropped folder's name prefixing every path. Read Total considered to confirm files were actually dropped, then fix the glob.
Error: Drop files or a folder first.
ErrorThrown when no files reach the tool. Causes: nothing dropped, or a browser quirk where an empty subfolder yields no File entries. Re-drop the folder and confirm it contains files.
Brace pattern matches nothing
By design{, }, , are literal in the compiled RegExp — there is no brace expansion. *.{ts,tsx} searches for a literal {ts,tsx} suffix. Run one pass per extension and merge with archive-merger.
Exclude/negative glob ignored
By designOnly one positive pattern is applied; !pattern is not recognised as negation (the ! is a literal character). To exclude, curate the dropped folder or use folder-to-zip + selective-extractor inverse.
Single `*` did not recurse
Expected* compiles to [^/]* and stays within one path segment. dir/* matches direct children only. Use dir/** to include nested files. This is the most common 'why didn't it match' cause.
Big folder near the tier cap
Tier capThe documented free cap is 50 MB / 500 entries; the entry-count cap often binds first for folders of many small files. Because everything runs in-tab via fflate, very large drops are also limited by browser memory. Drop a narrower folder or upgrade (Pro 500 MB / 50,000; Pro-media 2 GB / 500,000).
Output is ZIP, expected tar.gz
By designThe tool writes ZIP only via fflate (filtered.zip). It does not emit tar.gz, gz, or 7z. Convert the output with zip-to-tar-gz or archive-format-converter.
Timestamps reset on every entry
ExpectedThis build path writes default entry timestamps, not source mtimes — not a bug. If you need stable or original timestamps, run the output through timestamp-normalizer.
Processing seems to hang on a huge folder
Memory pressurefflate holds matched files in memory while building the ZIP. A very large matched set (near the 500,000-entry / 2 GB ceiling) can stress the tab. Narrow the glob so fewer files are read, or split the job into several smaller runs and merge with archive-merger.
Expected encryption but the ZIP opens without a password
By designSelective Zipper has no password/AES option — the ZIP is plaintext. For encryption, build the set here, then re-run it through encrypted-zip-creator for WinZip-compatible AES-256.
Frequently asked questions
Why do I get 'No files matched pattern'?
The glob caught zero files. The two usual causes: a single * where you needed ** (a * does not cross /), or the dropped folder's name prefixing every path so your src/... pattern never matches. Switch to **/*.ext or include the folder name, and check Total considered to confirm files were dropped.
Why is my brace pattern `*.{ts,tsx}` matching nothing?
Brace expansion is not supported — {ts,tsx} is treated as literal text. Run two passes (**/*.ts, **/*.tsx) and combine with archive-merger, or use a directory glob like src/**.
How do I exclude certain files?
You can't directly — only one positive glob is applied and ! is not negation. Curate the dropped folder, or use the inverse: folder-to-zip then selective-extractor with a keep-pattern.
Why did `src/*.ts` miss files in subfolders?
A single * matches within one path segment only ([^/]*) and does not cross /. Use src/**/*.ts to include nested directories. This is the most common matching surprise.
What are the size and entry limits?
The documented archive-family caps are: Free 50 MB / 500 entries, Pro 500 MB / 50,000 entries, Pro-media 2 GB / 500,000, Developer 2 GB / 500,000 / unlimited batch. The entry-count cap often matters first for folders of many small files. In practice your browser's memory is the real ceiling, since the ZIP is built in-tab via fflate.
Why is the output a ZIP and not a tar.gz?
Selective Zipper writes ZIP only (filtered.zip via fflate). Convert it with zip-to-tar-gz or archive-format-converter if you need another format.
Why don't the file timestamps match the originals?
This build path writes default entry timestamps rather than source mtimes — expected behaviour, not a bug. Run the output through timestamp-normalizer for stable or specific timestamps.
Can I password-protect the ZIP here?
No — there is no encryption option in this tool; the ZIP is plaintext. Build the set here, then encrypt it with encrypted-zip-creator (WinZip-compatible AES-256, also in-browser).
Why is nothing happening when I drop a folder?
If Total considered stays 0, the files never reached the tool. Some browsers yield no File entries for empty subfolders, and very large drops can take a moment. Re-drop, confirm the folder has files, and check the result panel after clicking Process.
Could a browser extension be breaking it?
Unlikely for this tool — it uses fflate (pure JS), with no WASM or server step, so extension interference is rare. If the tab is otherwise misbehaving, retry in a private/incognito window with extensions disabled to rule it out.
I wanted to extract from a ZIP, not build one — what now?
Selective Zipper is generative; it builds a new ZIP from local files. To pull matching entries OUT of an existing archive, use selective-extractor with the same glob. To extract everything, use multi-format-extractor.
How do I confirm the tool caught the right files?
Read the result panel: Matched is how many files the glob caught, Total considered is how many you dropped. If Matched is lower than expected, the glob or prefix is off; if it equals Total considered, your pattern matched everything (often a default *).
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.