Build a workflowGuide

Make a self-contained searchable reference pack

Keep a small set of supplied notes in one HTML file with literal search and exact source views.

Illustrative resourceNot tool-testedPeople turning a small authorized set of text notes into a portable reference copy

What you’re working towards

A complete self-contained HTML example containing six synthetic documents, literal text/filename search, exact source viewers and a no-JavaScript reading fallback. Its code is designed without external requests; actual offline browser opening remains a separate check.

Download playbook .md

Your choice also saves this guide’s current worked-example checkmarks. Only this browser; no account or sync. View saved guides

Saving needs JavaScript. Reading and downloading this guide does not save it.

Included example · illustrative HTML file

Download the searchable reference example

Self-contained six-document HTML with literal search, exact text views and a complete no-JavaScript fallback; actual browser/offline acceptance remains pending.

Not tool-tested. Review and adapt before using it for a real project.

Open example Download example

Source files to work with

Download the complete source manifest
All six logical paths and exact text, separate from the working HTML.
Download the readable source brief
Complete exact documents, search contract and sharing/reuse rules.
Download expected behavior and check scope
Concrete query/view expectations and separate local-code versus actual-browser gates.
Download the query answer sheet
Six source-linked query cases including empty and zero-result searches.
Download a blank pack brief
Reusable source, sharing, query and actual acceptance checklist without automatic folder access.

Before you begin

A small complete set of non-sensitive text you own or have permission to share with the chosen AI tool and intended readers
Exact logical path labels and source text, preserved separately
Explicit search behavior and independently specified expected matches
An intended browser and a real local-file/offline check before claiming that mode works

Possible tools

A text AI assistantUser-chosen text/code interface · required
Access and plan limits unverified
No named AI provider, plan, free route or intended browser/offline behavior was verified. The authored file has local source and minimal-DOM VM checks only. Use tools you already have access to and review real document sharing before using an AI service.
A source editorUser-chosen local text editor · suggested
Access and plan limits unverified
No named AI provider, plan, free route or intended browser/offline behavior was verified. The authored file has local source and minimal-DOM VM checks only. Use tools you already have access to and review real document sharing before using an AI service.
An intended browserUser-chosen browser and local-file opening mode · required
Access and plan limits unverified
No named AI provider, plan, free route or intended browser/offline behavior was verified. The authored file has local source and minimal-DOM VM checks only. Use tools you already have access to and review real document sharing before using an AI service.

Use the sample first. Remove private information before taking a prompt into another tool.

Make a start

One step at a time.

4 steps

Start with the synthetic worked example or other non-sensitive inputs. Run one prompt at a time in your chosen AI tool. Replace any bracketed placeholders with the requested material, check each reply, and supply the source or earlier outputs that step needs. Paste them again if the tool lacks that context.

Set up the worked example

Open: Open a fresh text/code-AI chat and a plain-text editor. This makes a small HTML page containing the supplied documents; it does not read a folder. A logical path such as notes/setup.txt is a label. Anyone who receives the HTML can read the whole pack, including search results that are hidden. Use the synthetic pack first.
Add the sample: Download/open document-pack-source.json and document-pack-source.md. Replace step 1’s placeholder with the complete JSON and all of ‘The starting point’ (Synthetic input), including the search and sharing rules; use Paper Table reference pack as its title and synthetic practice only as sharing scope. Keep ‘The intended result’ (Illustrative output) and document-finder-expected-queries.csv separate as answer references. Paste the complete checked manifest into step 2. Request the whole HTML and save only its code as my-document-finder.html, without chat fences or a .txt suffix. Reopen it in the editor before step 3, then paste/attach the original manifest and complete actual saved HTML; a local filename alone does not give the AI access. For step 4 provide that file, manifest, query answers, actual audit and intended browser. Open the actual saved file only in a permitted browser; its checks remain pending until observed. For the original advanced exercise return to this sample chat, provide the complete original manifest, actual saved HTML, query answers/checks and an explicitly supplied revised synthetic manifest. If no revision is supplied, leave it pending. A new chat needs the same complete context.

Start with the synthetic example, then adapt each prompt to your task.

Choose a small complete source pack

Start with the six synthetic notes. For your own pack, use only authorized non-sensitive text. The finished HTML includes every document, so hiding a search result does not make it private.

Your starting prompt

Organize the supplied documents into a complete source manifest with exact logical path labels and unchanged text. These labels are not permission to read a filesystem. Reject duplicate or Unicode-NFC-equivalent paths, traversal/absolute/remote path labels, unexpected fields and missing text. Do not scan folders or add files. Confirm that the source is non-sensitive and authorized for both the chosen AI tool and intended recipients; ask for a decision if that is unknown. Preserve originals separately.

PACK TITLE, SOURCE TEXT AND SHARING SCOPE:
[paste]

Expect: A complete manifest of six exact documents and their logical paths, with source permissions and the literal-search contract stated.
Check: Compare every path and text block with the original JSON, including terminal newlines and the accented café filename. No document should be summarized, added or scanned from a folder. The six documents are synthetic and all remain embedded in the finished file.
If it differs: If text or paths differ, supply the exact missing block and ask for the complete corrected manifest. Reject duplicate/NFC-equivalent labels, absolute/traversal/remote labels and unexplained fields. Do not continue with a partial pack.

Ask for one inspectable HTML reference file

The example uses native buttons, exact text views and a complete reading fallback. Search is literal; it neither calls AI nor invents an answer from the notes.

Your starting prompt

Build one self-contained HTML file from the validated source. Search complete logical paths plus text by literal substring after trimming the query, Unicode NFC normalization and lowercase conversion. Empty query shows all documents; sort paths by Unicode code points. Show exact source text when a native result button is activated, clear zero-result feedback, Clear search and a Back-to-selected-result control. Include all complete documents in native details disclosures readable without JavaScript. Render source text as textContent or escaped static text, never active HTML. Use labelled controls, visible focus, a polite result status and responsive layout. No external assets, fetch, file pickers, storage, uploads, analytics, AI calls or automatic file reading. Include an exact-hash restrictive CSP matching the final script and styles.

VALIDATED SOURCE:
[paste]

Expect: One complete HTML file, saved and reopened, containing the full pack, literal search, exact source views and all-document reading disclosures.
Check: Inspect the saved source against the manifest. Search must trim query whitespace, normalize NFC, ignore case, use literal substrings and order paths by Unicode code points. Native result buttons show exact text; Clear search and Back to selected result are explicit controls. All documents appear in the static fallback too. No network, storage, folder picker or AI runtime is needed.
If it differs: Ask for the full file if the response is a sketch, snippet or screenshot. Save/reopen the corrected copy. Fix escaping or exact CSP hashes rather than removing safeguards; do not let a quoted closing-script string become active markup. A source inspection cannot establish browser behavior.

Verify matches and every complete text view

The worked pack has two reading matches, three blank matches and one CAFÉ match. Reopen each result and compare its full text with the original, including newlines.

Your starting prompt

Independently check this HTML against the complete source, not only a screenshot. Verify exact embedded data and all no-JavaScript fallback text. Check empty, multi-match, uppercase, composed/decomposed Unicode, filename and zero-result queries. Open every result and compare all source text; verify one selected result, Clear, Back focus and hiding the old viewer after a new search. Test malicious-looking literal text and ensure it cannot create markup or requests. Recompute script/style CSP hashes. Distinguish static/VM code checks from actual browser interaction and do not claim semantic understanding or source accuracy from a string match.

ORIGINAL SOURCE:
[paste]

HTML:
[paste]

Expect: A source/text/query audit of the actual saved HTML, separating executed code checks from browser checks.
Check: Empty search should show all six paths. reading matches notes/close.txt and notes/setup.txt; blank matches drafts/ideas.txt, notes/setup.txt and reference/materials.csv; CAFÉ and its decomposed-accent form match reference/café.txt. reference/ matches three paths; unmatched phrase matches none. Compare full text, not snippets. A new query must hide the old viewer.
If it differs: For a mismatch, retain the query, expected paths, actual paths and full file. Ask for a complete repaired version with recalculated hashes, save/reopen it and repeat every text/query check. With no executable checker, do the available manual comparisons and label runtime cases not run. Do not claim source facts are true merely because text matched.

Open the real file before relying on it

The supplied example has local parser and VM checks. Browser layout, actual keyboard use and opening the saved file without networking are still checks for the intended environment.

Your starting prompt

Create a practical acceptance checklist for this reference pack in the intended browser. Include opening the actual saved HTML file, searching and viewing all expected results, keyboard focus/Back/Clear behavior, narrow-screen text wrapping, a JavaScript-off read-through and a real no-network opening. Record observed results only; leave unperformed checks pending. Review the full embedded source and recipient permissions before sharing, because every included document remains in the file. Do not scan personal folders, upload extra data or infer that a hosted page proves local offline behavior.

EXPECTED QUERIES, SOURCE AND INTENDED BROWSER:
[paste]

Expect: A checklist and, where actually performed, observations from opening the exact saved file in the intended browser.
Check: Type in Search filenames and text; activate the native result button displaying a path to open its full text. Use Back to selected result and Clear search, then the All source documents disclosures. Observe keyboard focus, narrow wrapping, JavaScript-off reading and a real local no-network opening. Review every embedded document before any authorized sharing.
If it differs: If a browser or offline check is unavailable, keep it pending. A hosted preview or code simulation is not a local-file test. If a control or source view fails, supply the complete saved source and exact observation for repair, preserve the earlier file and repeat the check on the new one.

Optional: improve the result

Regenerate a new edition without losing source lineage

A changed document pack is a new self-contained copy, not an automatic sync. Keep the previous edition, compare each logical document and rerun all checks.

Advanced prompt

Prepare a new edition from the explicitly supplied updated manifest. Compare original and new paths/text, list additions/removals/changes and reject ambiguous duplicate paths or unexpected data. Regenerate the complete HTML, including exact escaping and new CSP hashes, then rerun source-view, query, no-JavaScript and actual-browser checks. Do not scan folders, overwrite the previous edition, claim automatic synchronization or preserve a stale test result. Include the complete pack-sharing review again.

ORIGINAL MANIFEST:
[paste]

UPDATED AUTHORIZED MANIFEST:
[paste]

Optional: use your own input

Build a pack from your own authorized non-sensitive notes

Start a new chat with the prompt below. Supply the full text yourself; do not give the AI a folder path and expect it to scan. Resolve permission gaps first. Save the validated manifest separately as my-pack-source.json or an exact plain-text manifest, then write expected matches from that source before building the page. Send:
“Build one complete self-contained HTML file from MY COMPLETE VALIDATED MANIFEST. Preserve every logical path and text byte representation, including newlines. Search complete paths plus text by literal substring after trimming query whitespace, Unicode NFC normalization and lowercase conversion; empty query shows all documents in Unicode code-point path order. Use labelled controls, native result buttons, exact text views, Clear search, Back to selected result, a polite status and clear zero-result feedback. A changed query must hide the old viewer. Include every complete document in native details disclosures readable without JavaScript. Render content as text or escaped static text, never active HTML. No folder scanning, file picker, storage, uploads, network, remote assets, analytics or AI calls. Include restrictive exact script/style CSP hashes. Deliver the whole HTML, not patches. COMPLETE VALIDATED SOURCE AND SHARING SCOPE: [paste].”
Save only complete code as my-reference-pack.html and reopen it in the editor. Then send:
“Compare MY COMPLETE SAVED HTML against MY ORIGINAL MANIFEST and independently written query answers. Check every embedded and fallback path/text, including newlines; all documents appear once. Derive empty, multi-match, case, filename, no-match and composed/decomposed Unicode cases from my content; if a case is absent, use a separately labelled disposable synthetic control without adding it to my pack. Check all exact source views, selected-result state, new-query hiding, Back and Clear. Inspect literal hostile-looking text/escaping, no external requests/storage/file access and matching exact CSP hashes. Use read-only checks or disposable in-memory copies only; do not change my source to force a pass. Report actual tools/results and not-run cases, separating VM from browser evidence. ORIGINAL SOURCE, EXPECTED QUERY PATHS AND COMPLETE REOPENED HTML: [paste or attach full files if supported]. AVAILABLE TOOLS: [list or none].”
Keep failures; save/reopen any repaired complete version and repeat the audit. Then send:
“Prepare a practical acceptance checklist for MY exact saved HTML and intended browser. Cover opening from disk, every expected query/source view, keyboard focus/Back/Clear, narrow text, JavaScript-off full-source reading, and actual offline local opening with requests observed. Leave unperformed checks pending. Confirm every embedded document is suitable for every intended recipient before any separate authorized sharing. No automatic upload, sync or distribution. COMPLETE SAVED HTML, ORIGINAL SOURCE, QUERY ANSWERS AND ACTUAL AUDIT: [provide]. INTENDED BROWSER AND AVAILABLE TOOLS: [state].”
Follow the checklist yourself where permitted and record only what you observe. Changing a source file later does not change the pack: keep old editions, regenerate a new complete HTML with new hashes and recheck all content/query/browser expectations. Return to the sample chat for the original advanced prompt with both full synthetic manifests and the sample’s actual saved output; do not reuse its sample query counts on your notes.

Your own-input prompt

Help organize MY small explicitly supplied set of authorized non-sensitive text into a searchable reference pack. First validate exact logical path labels and complete unchanged text; preserve originals separately. Ask about missing text, ambiguous permissions or incomplete sharing scope. Reject duplicate or Unicode-NFC-equivalent paths, traversal/absolute/remote labels, unexpected fields and unsupported content; do not scan any directory or add documents. Explain that every recipient can inspect all embedded text. Use literal substring search of full paths plus full text, query whitespace trim, NFC normalization, lowercase comparison and Unicode code-point path order. Establish a complete manifest and independently source-derived expected query paths; do not generate semantic answers or claim the sources are factually correct. Stop for source/sharing review before HTML.

MY PACK
[Supply a title, intended recipients, permission basis for using this text with the chosen AI and including it in the finished file, each exact relative logical path with its entire text and newline information, and any query/expected-path cases you checked. Use no private or sensitive data. Mark unknown permission or missing text; do not provide only filesystem paths.]

Check your own result

Your actual document count, complete texts and expected query paths replace every sample count and keyword; no hidden document is private from a recipient.
Embedded data, every full viewer and the complete no-JavaScript fallback agree with your original manifest, including accented labels and newlines.
Only literal matching is promised. No source truth, semantic understanding, folder access, sync or persistence is inferred.
Each audit receives the complete saved/reopened HTML. Actual keyboard/layout/local offline opening and sharing review remain separate gates, with failures and unrun checks visible.

Show, then try

See the shape of the result.

This input is synthetic. The output is a written illustration of the intended result, not a verified AI-tool run.

The starting point

Synthetic input

# Complete synthetic document-pack input

Six owned synthetic text documents. No real project files or personal data. Logical paths are labels, not filesystem access.

## Exact search contract

Trim surrounding search whitespace; normalize query, logical path and source text to Unicode NFC; compare case-insensitively with literal substring matching. Empty query shows all documents. Results use Unicode code-point path order. No fuzzy, semantic or AI-generated answers.

## Documents

### notes/setup.txt

Each displayed block ends in one newline. Preserve its exact text and logical path.

```text
Reading table setup. Put pencils in the tray. Lay out blank cards.
```

### notes/close.txt

Each displayed block ends in one newline. Preserve its exact text and logical path.

```text
Reading table close. Return cards to the drawer. Count pencils.
```

### reference/materials.csv

Each displayed block ends in one newline. Preserve its exact text and logical path.

```text
item,count
pencils,12
blank cards,40
```

### reference/room.txt

Each displayed block ends in one newline. Preserve its exact text and logical path.

```text
Room note. Use the near table. Keep the spare table unused.
```

### drafts/ideas.txt

Each displayed block ends in one newline. Preserve its exact text and logical path.

```text
Ideas. A blank card can hold a sketch or a question.
```

### reference/café.txt

Each displayed block ends in one newline. Preserve its exact text and logical path.

```text
Café break. No venue or opening hours are supplied.
```

## Reuse rules

- Use only documents you own or have permission to include, and only non-sensitive input suitable for any AI tool you choose.
- The HTML contains its whole source pack. Anyone receiving it can read all included text, even when a search hides some results.
- This sample does not scan folders, upload files, run AI, fetch content, remember queries or preserve edits.
- A new pack requires replacing the full source and regenerating/rechecking the HTML. Source filenames do not authorize reading arbitrary paths.
- Do not infer missing facts or present the literal search as semantic understanding. Review source accuracy and sharing before distributing a real pack.

Copies text only. For image or file tasks, use the source files named in the steps too.

Download source .txt

The intended result

Illustrative output

# Search and source checks for this reference pack

The working example contains exactly six owned synthetic documents. It searches the complete logical path plus complete text using a literal substring after Unicode NFC normalization and lowercase conversion; it trims surrounding query whitespace. It does not generate answers, infer meaning, scan folders or fetch documents.

## Exact query expectations

- Empty query: all six logical paths in code-point order.
- reading: notes/close.txt and notes/setup.txt.
- blank: drafts/ideas.txt, notes/setup.txt and reference/materials.csv.
- CAFÉ: reference/café.txt.
- cafe followed by a combining acute accent: the same reference/café.txt result.
- reference/: all three reference documents.
- unmatched phrase: zero results, with a clear suggestion to shorten or clear the query.

Each result's Open action is its native button. The viewer must show the complete exact source text, not a generated summary. Clear search restores all six results. A new query hides the previous viewer so that a stale result is not presented as a new match. Back to selected result returns focus to that result. All six complete source documents also remain in native disclosures below the interactive tool, including when JavaScript is off.

## Local checks actually performed

On 14 October 2026, the embedded JSON, complete static fallback text, exact script/style CSP hashes and all six rendered-source labels were compared with the independent source files. The actual script was executed in a minimal DOM VM: eight query cases, all six source-view transitions, single selected-result marking, focus requests, Back and Clear behavior passed. A malicious-looking text string was preserved as a textContent value. Full code-point ordering was checked against a supplementary Unicode character.

A separate read-only construction check reproduced the HTML exactly, rejected 15 malformed or oversized source cases, and verified that literal closing-script/title strings create no extra active markup. CSP-like source literals remain unchanged. HTML-parser checks preserve CRLF, lone CR and initial newlines in the fallback; unsupported NUL text is rejected. Path labels are never used to read a filesystem. No network, file-picker, storage or unsafe HTML-insertion API is present in the reviewed runtime code.

## Checks still to perform before real use

Open the actual HTML in the intended browser, test keyboard focus and narrow wrapping, then open the saved file with networking unavailable to check the intended offline use. Real browser layout, actual keyboard events, local-file opening, assistive technology and offline behavior have not yet been verified for this example. Review every real source document and sharing permission. Anyone receiving the HTML can inspect the entire embedded pack, not merely visible matches. No consumer-AI workflow or time saving was measured.

Download result .txt

You’re the final check

Check the worked example.

These checks use the worked example and its particular facts. With your own material, check your actual names, numbers, sources and rules; do not reuse the sample’s values as the answer.

All six complete source documents appear once in embedded data and the static fallback.reading returns two notes; blank returns three documents; CAFÉ and its decomposed-accent form return the same one document.Empty search shows all six paths; a genuine no-match stays empty and offers Clear search.Each opened viewer preserves the entire exact text; search changes hide a stale viewer.Runtime code has no external requests, folder scanning, storage, unsafe HTML insertion or AI calls; exact CSP hashes match.Actual browser keyboard/layout/offline opening and recipient/source review remain distinct checks before real use.

Unsaved checks stay in this tab and reset when you reload. If you choose Save guide, its current example checkmarks are kept in this browser when storage is available.

A few things to watch for.

Calling literal substring search semantic search or inventing an answer from a match.
Mistaking hidden search results for privacy or access control.
Passing real private documents to an AI service without reviewing data permissions.
Reading arbitrary paths or silently adding files beyond the supplied manifest.
Rendering source content as HTML or changing source text to make the preview look cleaner.
Claiming offline, browser or assistive-technology compatibility from a VM or hosted-page check alone.

What has been checked?

Documentation: No dated source review recorded.
Included files: Scoped checks passed on 2026-10-14. Fixture checks. See scope below.
AI workflow: Not run in a recorded consumer-AI workflow.
Time savings: Time savings not measured

Read the scope and evidence