Skip to content

armgit / bento

Public Imported from GitHub
0

Bento, the office suite that fits in a file

Grant as many folders as you like — resolve by route, not by search (#299)

nyblneta5bc3f14d2e0
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 45ab7d0f..bb09fbcd 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -295,6 +295,47 @@ jobs:
# rather than by reloading an extension and pressing Cmd-S.
run: node scripts/test-webext-bridge.ts
+ - name: WebExtension route rig
+ # Turning an absolute path into "where this granted folder lives", from
+ # paths the extension did not choose — browser history, for files that
+ # may have moved or never been in a grant at all. Getting it wrong does
+ # not produce a broken link; it records a folder at the wrong place and
+ # every document in it silently opens something else. So it must prove,
+ # never guess: the route resolves inside the grant AND dir.resolve()
+ # agrees with the path's own tail.
+ run: node scripts/test-webext-route.ts
+
+ - name: WebExtension document-library rig
+ # The popup is a document browser, and everything in it is DERIVED from
+ # files on disk: the title out of the document block, the thumbnail out
+ # of the preview block, the openable path out of a learned prefix. Each
+ # is a parse against a format that moves, and each fails quietly — a row
+ # showing a filename instead of a title, or a blank square. Nothing
+ # throws, so nothing reports it.
+ #
+ # Runs AFTER the slides build on purpose: it reads the real shell, and
+ # with a document spliced in at the real offset. Hand-written fixtures
+ # would have passed the bug this replaces, where a metadata reader hunted
+ # for the document block's CLOSING tag and so found nothing in any
+ # document carrying an image.
+ run: node scripts/test-webext-library.ts
+
+ - name: WebExtension update-notice rig
+ # Store installs update themselves; one loaded unpacked never will, and
+ # Chrome ignores update_url for a development install. So the GitHub
+ # route has to be told — and told in exactly one direction: a store user
+ # must never see a notice they cannot act on, and must not even cost a
+ # request. Every failure mode here is silent by nature.
+ run: node scripts/test-webext-update.ts
+
+ - name: WebExtension localisation rig
+ # Every failure mode of a message catalogue is silent: a key the code
+ # uses but English lacks renders as the key name, a locale missing a key
+ # falls back so a German page carries English sentences, and a dropped
+ # $1 leaves a hole in a translated sentence. All of them are visible
+ # only to someone who reads that language.
+ run: node scripts/test-webext-i18n.ts
+
- name: Save-intent rig
# A host polyfilling showSaveFilePicker sees only the options bag, and
# must tell "overwrite the open document" from "make a second file" from
diff --git a/docs/DECISIONS.md b/docs/DECISIONS.md
index c37d0410..c70c6d08 100644
--- a/docs/DECISIONS.md
+++ b/docs/DECISIONS.md
@@ -2357,3 +2357,892 @@ satisfied the `instanceof` branch but has no `.text()` — so every `close()`
rejected and the half of the bridge that actually sends bytes had never been
exercised, across 24 green checks. Mocks shaped to make a test pass test the
mock.
+
+---
+
+## 2026-08-14 — resolve by route, not by search (and the grant lapses every restart)
+
+**MEASURED, on the reporter's machine:** a `showDirectoryPicker` grant survives
+service-worker eviction, but Chrome drops it to `prompt` when the browser
+restarts. The HANDLE survives in IndexedDB — the options page still knows the
+folder's name — so only the permission is gone, and `requestPermission()` on the
+held handle takes it back with one confirmation. That must run on an extension
+PAGE (it needs a user gesture; the worker has none), which is what the
+per-folder **Renew** button is.
+
+**That "one click per browser session is the ceiling" — WRONG, corrected the
+same day.** The claim was that Chrome's persistent File System Access
+permissions are scoped to installed web apps, so a pure extension could never do
+better. Then the reporter screenshotted the actual dialog, on
+`chrome-extension://…/src/options.html`, and it offers three buttons: *Allow
+this time*, **Allow on every visit**, *Don't allow*. Persistent permission IS
+offered to an extension origin.
+
+The lesson is the one this log keeps relearning: I reasoned about a permission
+UI from documentation instead of looking at it, and stated the conclusion firmly
+enough that it nearly settled a distribution decision — native messaging, a
+signed binary per platform — that may not be needed at all.
+
+**MEASURED 2026-08-14, and it holds: "Allow on every visit" SURVIVES a full
+browser restart** for an extension origin — quit Chrome, reopen, the folder
+still saves in place with no renewing. So the grant is once and for all, and
+native messaging is moot. The distribution model stands: install from the Web
+Store, grant a folder, done.
+
+What is left is not a permission problem but a DISCOVERY one, and the two failure
+directions are unequal. Choosing "Allow this time" costs a re-grant every
+session and never says so; choosing "Allow on every visit" costs nothing. So the
+extension names the button, and the first grant is the only moment anyone should
+have to think about it.
+
+The dialog can only be raised from an extension PAGE with a user gesture —
+`requestPermission` needs the gesture, and the service worker has none. A deck
+is a `file://` page in another origin that cannot hold the handle at all. So
+"raise it from where the user is" is not available; the best reachable is to put
+the button where the user already is when it matters (the toolbar popup), and to
+make a lapsed grant VISIBLE before a save fails rather than after.
+
+**Resolution no longer searches.** A `FileSystemDirectoryHandle` knows its name
+but not its path, so the host walked the granted tree matching filenames —
+depth-capped at 4, declining whenever two files shared a name. But a directory's
+NAME must appear in the path of every file inside it. So the name locates the
+split point in the sender's path and the rest is a route: `getDirectoryHandle`
+per segment, then `getFileHandle`. Measured: a file inside a 500-entry grant
+resolves with ZERO directory scans.
+
+That one change is what makes the rest possible:
+
+- **any grant size.** A home directory costs what a decks folder costs, so
+ "grant everything" stops being a performance question.
+- **several grants**, since each attempt is a few lookups. The store holds a
+ list (`dirs`); the old `dir` key is still read so an upgrade does not silently
+ drop the folder someone already granted.
+- **two documents sharing a filename stop being ambiguous** — a BEHAVIOUR
+ CHANGE, and the old decline was a limitation rather than a safety property.
+ Only one route leads to one file. Anyone with per-client folders hit the old
+ decline on every save.
+
+The route is checked, not guessed: a wrong split point fails at the first
+missing segment, and `resolve()` re-verifies what it landed on against the
+sender's path regardless. A grant covering a home directory raises the cost of a
+resolution bug, so that check matters MORE now, not less.
+
+**A file reachable through two nested grants is one file, not an ambiguity** —
+`isSameEntry` decides, since it is the only thing that can tell "same file, two
+routes" from "two files, same name". Two genuinely different files reachable by
+the same route still decline.
+
+**A lapsed grant is reported distinctly from a missing one**, and only when NO
+grant could serve the file — with several folders, one lapsing must not mask the
+others, and the two need opposite things from the user: one click, or a folder.
+
+**Guards.** `scripts/test-webext-background.ts` (57 checks): per-grant
+resolution, the lapsed-among-healthy case, nested grants, two-different-files,
+and a 500-entry grant asserting `enumerations === 0` — the last is the one that
+would catch a silent return to searching. Plus a source-level gate that
+`background.js` and `status.js` agree on the database, store and keys: they open
+IndexedDB independently and cannot be loaded into one realm, so drift would mean
+the options page writes grants the worker never sees — UI green, every save
+prompting, nothing reporting a fault.
+
+*Found in passing:* the rig carried a LITERAL NUL byte in a test case, which
+made `grep` treat the whole file as binary and hid it from ordinary tooling. It
+is now written as a `` escape.
+
+*Amended 2026-08-14, later.* Two corrections to the entry above, both from
+looking rather than reasoning.
+
+**`chrome://settings/content/filesystemwrite` does not exist.** I put it in the
+options page and in STORE.md without visiting it. Chrome's documented ways to
+withdraw File System Access are the address-bar icon's *Remove access* and a
+per-site *File editing* list reached from it — both part of the site-settings
+surface for a website origin. That surface is NOT offered for
+`chrome-extension://` pages: the chip there reports only "You're viewing an
+extension page". Chrome's own write-up demonstrates the feature on vscode.dev
+and does not mention extension origins at all.
+
+So there appears to be **no user-facing control to revoke File System Access
+granted to an extension origin**, and reinstalling does not clear it either —
+an unpacked extension's id comes from its directory path, so re-loading from the
+same path returns to the same origin, still granted. A different path is a
+different id and a clean slate.
+
+**And "Remove only forgets the folder, it does not revoke" was wrong** — the
+pessimistic direction, but wrong. The permission is not the capability; the
+HANDLE is. With no handle stored there is no object to write through, and
+another can only come from the user picking a folder. Deleting it takes the
+access away for real. Chrome's remembered permission means only that re-picking
+that same folder may not ask again.
+
+Which settles where this leaves the product: **the extension's own folder list
+is the only place access can be withdrawn**, so it is not a convenience — it is
+the control, and it says so on the page. A reviewer will ask; STORE.md answers
+it in those terms.
+
+Three wrong claims about browser behaviour in one day (persistent permissions
+scoped to installed apps; a settings URL; Remove not being a revoke), each
+stated confidently from documentation or memory, each disproved by one
+screenshot. The rule that keeps being relearned: a claim about a browser UI is
+worth nothing until someone has looked at that UI.
+
+---
+
+## 2026-08-14 — "Don't allow" is a one-way door, and the prompt can be embargoed
+
+Reported: after choosing **Don't allow** on the reconnect prompt, the folder
+grant lapsed on every browser restart AND the dialog stopped appearing at all.
+Read out of the Chrome profile (`Profile 1/Preferences`), two independent things
+had happened, neither of them a recorded "block":
+
+**1. The granted folders were DELETED.** `file_system_access_chooser_data` for
+the extension went from two directories with paths to `"chosen-objects": []`.
+The extension's stored handles survive in IndexedDB, but they now refer to a
+grant Chrome no longer has, so there is nothing for `requestPermission` to
+restore.
+
+**2. The restore prompt is EMBARGOED.**
+
+ permission_autoblocking_data → FileSystemAccessRestorePermission
+ { "dismiss_count": 3, "dismissal_embargo_days": … }
+
+Chrome's permission auto-blocker suppresses a prompt after three dismissals.
+`permission_actions_history` is empty and `file_system_write_guard` holds no
+BLOCK — the silence is purely the embargo. `requestPermission` returns without
+showing anything, so the button appears to do nothing, permanently.
+
+**Neither is reachable from Chrome's UI**, for the same reason the persistent
+grant was not: these live in their own stores, not in the content-setting
+exceptions the settings page renders.
+
+### What this changes in the product
+
+**A Renew button is a loaded gun.** Every prompt the user dismisses counts
+toward the embargo, so a UI that encourages clicking it — a notification, say —
+makes the dead end easier to reach. Three impatient dismissals and saving
+silently stops working.
+
+**Re-picking is the escape, and it is a DIFFERENT permission.**
+`showDirectoryPicker` is a user-initiated chooser, not a restore prompt, so it
+still works under embargo and re-creates the chosen-object. So a failed renew is
+not an error to report — it is the signal to ask for the folder again. Both the
+options page and the popup now detect a renew that restored nothing and say so,
+rather than reloading into an unchanged list, which reads as a broken button and
+invites exactly the extra dismissals that cause the embargo.
+
+**This is the strongest argument yet against raising prompts on our own
+initiative.** Nothing may open the restore prompt except an explicit user click,
+and the copy has to be clear enough that the click is deliberate — because the
+cost of a careless dismissal is not a retry, it is the feature.
+
+### Still unknown
+
+Whether the embargo expires on its own (`dismissal_embargo_days` holds what
+looks like a timestamp, not a count of days) and whether re-picking clears it.
+Worth knowing before the store listing claims anything about recovery.
+
+*Amended 2026-08-14, from the Chromium source.* The embargo has numbers, and
+they change how the UI must behave.
+
+`components/permissions/permission_decision_auto_blocker.cc`:
+
+- `kDefaultDismissalsBeforeBlock = 3`
+- `kDefaultEmbargoDays = 7`
+- `FILE_SYSTEM_ACCESS_RESTORE_PERMISSION` is in the auto-blocked content types
+
+`IsUnderEmbargo` is a timestamp comparison —
+`current_time < base::Time::FromInternalValue(*found) + offset` — so the stored
+value is the embargo's START (microseconds since the Windows epoch) and the
+duration is applied at comparison time. **It expires on its own after seven
+days.** The field name `dismissal_embargo_days` describes what the number is
+for, not what it holds; reading it as a duration was wrong.
+
+**Nothing an extension can call lifts it.** `RemoveEmbargoAndResetCounts` is
+C++-internal, reached from browser UI paths, and `chrome.browsingData` has no
+`siteSettings` type at all — its `origins` filter covers cookies, cache and
+storage only. The user-facing escapes are: wait it out, *Clear browsing data →
+Site settings* (profile-wide, so it resets every site's permissions), edit
+Preferences directly, or move to a different extension id.
+
+### The cost is persistence, not delay
+
+The restore prompt is ALSO the only place **Allow on every visit** is offered.
+Picking a folder afresh grants access without offering it. So an embargo does
+not merely postpone a reconnect — for seven days it removes the user's ability
+to make the grant permanent at all, and the extension will lapse on every
+restart with nothing on screen explaining why.
+
+### Which makes three dismissals a budget to spend carefully
+
+The popup's Reconnect looped over every lapsed folder calling
+`requestPermission` on each, so one impatient click on a two-folder setup spent
+two of the three. That is an embargo accelerator, and it is the likely reason
+the reporter reached the limit within minutes of the button existing.
+
+Now: **one prompt per click, stopping at the first refusal.** Whatever made
+someone refuse the first prompt applies to the second, so continuing buys
+nothing but embargo.
+
+The same reasoning condemns anything that raises the prompt on our own
+initiative. A notification that nudges toward the button is a nudge toward the
+dead end, and that trade — a rare lapse made visible, against a permanent
+downgrade made likelier — is not obviously worth taking. Left in for now with
+the loop fixed, but it should be decided deliberately before this ships.
+
+*Amended 2026-08-14, measured cleanly.* The entry above ran two effects
+together. Reset to a clean grant, restarted, pressed **Don't allow** exactly
+once:
+
+ permission_autoblocking_data → FileSystemAccessRestorePermission
+ { "dismiss_count": 1 } ← no dismissal_embargo_days key
+ file_system_access_chooser_data
+ { "chosen-objects": [] } ← already empty
+ file_system_last_picked_directory ← gone entirely
+
+They are separate, and the ORDER matters:
+
+**One "Don't allow" destroys the grant.** Immediately, on the first refusal —
+not after three. `chosen-objects` is emptied and the last-picked directory
+cleared, so every stored handle is orphaned and the folder has to be picked
+again. This is the damage that actually bites people.
+
+**The embargo is secondary.** `dismissal_embargo_days` only appears at
+`dismiss_count = 3`, so three refusals are needed for the seven-day block. An
+explicit "Don't allow" counts toward the DISMISSAL budget, the same as closing
+the bubble with the X.
+
+So the earlier telling — that "Don't allow" left the user embargoed — was two
+findings collapsed into one. The first refusal costs the folders; the third also
+costs persistence for a week.
+
+### The dialog does not say any of this
+
+Chrome asks *"View and edit files from the last time you visited this site"* with
+*Allow this time* / *Allow on every visit* / *Don't allow*. Nothing there
+suggests that refusing DELETES a grant the user already made rather than
+declining for now, and the wording invites a cautious person to refuse. It
+cannot be changed from an extension.
+
+So the warning goes where we do control it — on the button that raises the
+prompt, and in the status line above it. Both branches are spelled out, because
+Chrome's wording gives no clue about either: *Allow this time* costs a repeat
+next session, *Don't allow* costs the folder.
+
+### And a failed renew must not offer Renew again
+
+Retrying is the losing move: it has already failed once, and each attempt spends
+one of the three dismissals, while re-picking costs nothing and always works. So
+a row whose renew failed hides its Renew button and offers only **Choose
+again…**. The budget is small enough that the UI must not invite people to spend
+it on a repeat.
+
+*Amended 2026-08-14, and this is the one that matters for shipping.* Several
+rounds of renew-and-restart later, with successful grants in between:
+
+ permission_autoblocking_data [17:35:52] { "dismiss_count": 1 }
+ file_system_access_chooser_data [17:41:37] both folders back, writable
+
+**`dismiss_count` did not move.** Six minutes and several successful grants
+after it was set, it is still 1. A grant does not refill the budget.
+
+Confirmed in `permission_decision_auto_blocker.cc`: `RecordDismissAndEmbargo`
+only increments, no path resets counts on a grant, and nothing decays them over
+time. They are cleared only by `RemoveEmbargo` — which no extension can call.
+
+### So the three-strike budget is per-origin and LIFETIME
+
+Not per session, not self-healing. A user who refuses the dialog three times
+across months of ordinary use arrives at the same seven-day embargo as one who
+does it three times in a minute.
+
+And by the shape of the code — inference, not yet watched — once the count
+reaches 3 it stays ≥ 3, and the embargo is re-applied whenever the threshold is
+met. After three lifetime refusals, **every** later refusal would cost another
+week.
+
+That changes how much the mitigations are worth. One prompt per click, no retry
+after a failure, and a warning on the button are not polish; they are the only
+things standing between an ordinary user and a permanent-feeling breakage,
+because the budget never comes back.
+
+### Also observed: allowing does not imply persisting
+
+After all the re-granting, `file_system_access_extended_permission` is still
+empty — access works, but session-scoped, so the restore prompt returns on every
+restart. Persistence comes ONLY from choosing "Allow on every visit" on that
+prompt. A user who keeps choosing "Allow this time" gets a working extension
+that asks forever, and nothing tells them the other button exists. Which is why
+the copy names it in both surfaces.
+
+*Corrected 2026-08-14. The entry above overstated the damage, and it was
+recorded as measured fact — so read this one instead.*
+
+**"Don't allow" does not destroy the grant.** It empties `chosen-objects`
+immediately, which is what the earlier reading saw. But the extension's stored
+handles survive, and the restore prompt eventually returns and re-acquires
+EVERY folder at once through `requestPermission`. No re-picking is required.
+
+Confirmed by the reporter: after refusing, they clicked **Renew** and only
+Renew, across at least three browser sessions, and both folders came back
+together. The evidence in the profile agrees —
+`file_system_last_picked_directory` is absent (picking a folder sets it) while
+`chosen-objects` was rewritten with both entries in one go, which is a restore,
+not two picks.
+
+**The prompt returns on a delay of more than one restart.** Those earlier Renew
+clicks displayed NOTHING — `dismiss_count` stayed at 1 throughout, and a shown
+prompt that is refused increments it. So `requestPermission` was returning
+silently for two or more sessions before Chrome chose to ask again. What governs
+that interval is not known; it is not the embargo, which never engaged.
+
+### What this changes
+
+**A silent Renew is "not yet", not "never".** The UI had been rewritten to treat
+it as terminal and steer to re-picking — which trades a permanent grant for a
+session-scoped one, since **Allow on every visit** appears only on the very
+prompt being waited for. Both surfaces now say the honest thing: it usually comes
+back after a restart, sometimes a later one; re-pick only if you would rather not
+wait, and know what that costs.
+
+**Hiding Renew after a failure stays**, but only for that visit — the row is
+rebuilt on reload, so nothing is permanently withheld.
+
+### On being wrong twice about the same click
+
+The first reading ("Don't allow empties chooser_data") was correct but partial;
+the conclusion drawn from it ("re-picking is the only way back") was invented to
+join it to the embargo finding, and shipped as fact in copy and in this log. The
+reporter's own sequence — Renew, restart, repeat — is what disproved it. A
+measurement explains what it measured, and nothing about what would have happened
+next.
+
+*2026-08-14, from the source, and the resulting strategy.*
+
+`chrome/browser/file_system_access/chrome_file_system_access_permission_context.cc`
+gates the restore prompt on the grant being DORMANT:
+
+ context_->GetPersistentGrantType(origin_) != PermissionDatabaseType::kDormant
+ context_->IsEligibleToUpgradePermissionRequestToRestorePrompt()
+
+So there is a state machine — no grant / active / dormant — and
+`requestPermission` produces the restore dialog only when there is a dormant
+grant to restore. That, not a cooldown, is why Renew returned silently for two
+sessions after a refusal and then worked: the docs show no backoff or
+rate limit on this prompt. The exact transition rules into dormancy are NOT
+established here; the gate is quoted, the rest is not guessed at.
+
+### The strategy: prime before the prompt
+
+Two facts settle what can be done, and neither depends on the unresolved part:
+
+1. **"Allow on every visit" exists only on the restore prompt.** Picking a
+ folder afresh grants access without offering persistence. So that dialog is
+ the single opportunity, it cannot be summoned on demand, and a wasted one
+ costs at least a restart.
+2. **The state is detectable.** At browser startup, before any user action,
+ `queryPermission` returns `granted` when extended permission is live and
+ `prompt` when the grant is session-scoped. `onStartup` already runs that
+ check, so the extension knows — silently and reliably — that someone is stuck
+ on "Allow this time".
+
+Chrome's dialog is three near-identical pills, and its wording ("View and edit
+files from the last time you visited this site") says nothing about what any of
+them costs. "Allow this time" is the cautious-looking choice and the one that
+guarantees being asked forever. Prose cannot point at a button, so both surfaces
+now DRAW the dialog with the middle option marked, and only then offer to raise
+it.
+
+That is the whole lever. There is no API that grants persistence, no way to
+influence which options Chrome shows, and no way to re-ask sooner. What is left
+is making sure that when the one prompt appears, the user already knows which
+button they came for.
+
+**Corollary for the notification.** Its job changes: not "a folder lapsed" but
+"the one prompt that can fix this permanently is available now". That is a
+better reason to interrupt than the original one, and it argues for keeping it —
+provided it always lands on the primed popup rather than raising the prompt
+directly.
+
+---
+
+## 2026-08-14 — the extension is a document browser, not a permissions panel
+
+The popup's entire content was plumbing: *local file access is on, folder:
+documents*. True, and nobody wants it. `tray/ios` is a
+`UIDocumentBrowserViewController` — you see your documents and tap one — and
+that is the right shape here too. So the tray now lists documents with real
+titles and page-one thumbnails, and permission state is one line at the bottom
+that stays quiet while things work.
+
+Four pieces, three of which reuse something that already existed.
+
+**Clickable rows come from `locateIn` run backwards.** A directory handle knows
+its name and never its path, so the extension can WRITE a document it cannot
+URL. But `resolve()` holds both halves at one instant: `sender.url` is absolute
+and browser-stamped, and `dir.resolve()` gives the same file's route from the
+grant root. Subtract, and the grant's absolute prefix falls out; store it and
+every document in that folder becomes openable. Bootstrapping costs one document
+opened the ordinary way, which is the premise of the product. A folder that has
+never taught us its prefix still lists — the rows just say they cannot be
+opened, rather than doing nothing when clicked.
+
+**Titles come out of the document block**, which starts ~6KB in, so a fixed
+300KB head reaches it. Matching the field directly matters: an earlier metadata
+reader looked for the block's CLOSING tag and therefore found nothing in any
+document carrying an image, since those blocks run to megabytes. The rig pins
+that case explicitly.
+
+**Thumbnails were already written.** `preview.ts` puts a still render of page one
+into every saved document so file managers can thumbnail it, and this IS a file
+manager. The block is self-contained and scales itself to whatever viewport it
+lands in, so it drops into a 56×32 sandboxed iframe with no work — exactly what
+it was built for. Encrypted documents deliberately carry none, so those show a
+lock, and a document never saved shows a page glyph rather than broken-looking
+white.
+
+**`+ New document` fetches the signed release** rather than bundling a seed.
+Bundling would put a copy of Bento inside the extension, to drift from the real
+release and be re-reviewed on every update — the same trap `tray/ios` avoided by
+letting documents carry their own runtime. De-duplication counts on the BASE
+name (`Untitled 2.bento.html`), because UIKit's own counter produces
+`Untitled.bento 2.html` from a double extension and `tray/ios` had to write its
+own for the same reason.
+
+### Enumeration is allowed here, and that is not a contradiction
+
+`background.js` went to some trouble to STOP enumerating: resolving a save must
+not walk a folder, because the user is mid-⌘S and a granted home directory would
+hang it. Listing is user-initiated, bounded (depth 4, 300 documents) and cached.
+Same folder, different job, different rules — worth stating because the two
+sit next to each other and the next reader will wonder.
+
+### One store, one owner
+
+`background.js` and `status.js` each opened IndexedDB with their own copies of
+the database name, store name and keys, guarded by a rig comparing the two. That
+gate is gone because the duplication is: `db.js` owns the store and both import
+it. The rig now asserts the stronger thing — that nothing else calls
+`indexedDB.open` — since a second opener is how the split-brain returns, and its
+symptom is the options page writing grants the worker never reads.
+
+### Verified by looking
+
+The layout was rendered with a real preview extracted from a real saved deck and
+screenshotted, not asserted. The library rig reads the real built shell, and a
+copy of it with a document spliced in at the real offset — hand-written fixtures
+would have passed the metadata bug that shipped.
+
+Found while writing it: a PRISTINE shell has an EMPTY `#bento-doc` block
+(`id="bento-doc"></script>`) because the starter document is built at runtime and
+only written on first save. So a newly created document legitimately has no title
+and no preview until it is saved once. The rig asserted a title and failed —
+correctly, at the assertion rather than in the parse.
+
+*2026-08-14, continued: the home page, and the bug that made the tray useless.*
+
+**The tray listed documents and could open none.** A chicken-and-egg: a
+directory handle has no path, so an absolute one is needed to open anything, and
+it was learned only by subtracting during a SAVE. A fresh install had never
+saved, so every row was disabled. Opening a document is the natural moment to
+learn where its folder is, so `relay.js` now announces itself once on load and
+the worker resolves that like a claim — no write, prefix recorded. One document
+opened makes its whole folder openable. The announcement sends an op and
+nothing else; the path still comes from `sender.url`.
+
+**A full page, because a popup cannot browse.** 340px that dies on blur answers
+"open the thing I just had" and nothing else. `src/home.html` adds folders,
+search, sort, and thumbnails big enough to recognise a deck by. The popup stays
+a launcher with a door to it, rather than a second implementation — both read
+`library.js`, so they cannot disagree about what a document is.
+
+**Thumbnails need a real viewport, not a small one.** The preview block sizes
+page one to whatever viewport it lands in. Give the iframe a 56px box and it
+lays the slide out for a phone; give it 1280×720 and scale the whole frame down,
+and it composes exactly as it does on screen. Measured while looking at it: the
+first screenshot showed blank cards because the iframes had not painted yet, not
+because anything was wrong — a reminder that "I looked and it was broken" needs
+a second look before it becomes a finding.
+
+**Rename is write-then-remove, in that order, always.** The File System Access
+API has no rename. If the write fails the original is untouched; if the remove
+fails the worst case is two copies. Removing first would put the only copy of
+somebody's document in a variable, and the rig proves the ordering by failing
+the write and checking nothing was removed.
+
+**The rename box is a filename input, so it is sanitised as one**: separators
+stripped so nothing escapes the folder, the extension stripped so typing it does
+not double it, and leading dots stripped — a document renamed to `.something`
+would vanish from every file manager including this one.
+
+**Duplicate copies bytes, deliberately.** A Bento document carries its own
+runtime, its collaboration keys and its identity. Whether a copy should get a
+fresh `docId` is the DOCUMENT's business — Bento has "Duplicate as new deck" for
+exactly that — and a file manager has no standing to decide it.
+
+**There is no Delete**, and that is a decision rather than an omission.
+Destroying documents needs an undo, a trash, and a confirmation people actually
+read; Finder has all three and is one keystroke away. Duplicate and rename are
+recoverable, delete is not.
+
+**Multi-app support was deferred, deliberately.** Supporting other single-file
+HTML apps means widening the manifest match from `file:///*.bento.html` to all
+local HTML, which injects the bridge into every local page a user opens — a much
+larger thing to justify in a store listing — and replacing the `window.bento`
+version gate with a generic app declaration. That gate is what stops a pre-#213
+document from having its "Save a copy" treated as an overwrite, so it cannot be
+dropped casually. Doing it first would have settled the home page's data model;
+doing it later means the home page will need revisiting. That is the cheaper
+order, because Bento's own shape is known and another app's is not.
+
+*2026-08-14, continued: does the tray handle Spaces and Dash?*
+
+Mostly yes, already — and the exception was a real bug nobody had noticed.
+
+**Listing, opening, thumbnails and in-place saving were never app-specific.**
+The whole family writes `.bento.html`, shares the kernel's `title` field, and
+slides/spaces/dash all register a preview. So the tray shows them all, with
+titles and page-one thumbnails, without knowing which app it is looking at.
+(`type` does not exist on main yet.)
+
+**But bento/dash could not save in place at all.** `page-bridge.js` refuses to
+write unless the runtime is at least 1.0.15, because before `pickerIdFor` (#213)
+every save sent `bento-doc` — including "Save a copy…" — and acting on that id
+overwrites the open document. It read the version from
+`window.bento.updates.version`, which each app assembles BY HAND: slides has it,
+spaces has it, **dash never included `updates`**. So every ⌘S in Dash fell
+through to a destination prompt, with a folder granted and nothing on screen
+saying why. It would have looked like the extension being broken.
+
+The bug is not that Dash forgot. It is that a contract with a host was being
+satisfied by each app remembering to. So the signal moved to where it cannot be
+forgotten: `configureApp` is the one call every app makes, and it now announces
+`window.__bentoRuntime`. The next app inherits the fix without knowing it
+exists.
+
+The bridge reads BOTH — the announcement first, the hand-made object as a
+fallback — because every already-shipped Slides and Spaces document has only the
+latter, and dropping it would break in-place saving for every file already on
+disk. Both are still gated at 1.0.15; an announcement is not a reason to trust a
+runtime that predates the id.
+
+Non-writable, for the same reason `__bentoHost` is: the document shares that
+realm, and a document that could overstate its own version could talk a host
+into overwriting it.
+
+**Creating a document is the one operation that must ask which app**, because
+there is no document yet to say. `library.js APPS` lists the three with their
+own signed release channels, and `+ New document` offers them. Adding an app is
+that one entry; nothing else in the extension asks.
+
+Fetched rather than bundled, for the reason `tray/ios` does not bundle a shell:
+a bundled seed drifts from the real release and drags the extension into a
+review queue on every Bento update. A document created here is the build
+everyone else has that day.
+
+*2026-08-14, and this one was a design failure, not a bug.*
+
+The tray shipped with a first run that read: every document greyed out, and a
+paragraph explaining that you must go to Finder and double-click something
+before the extension works. Reported, correctly, as *"this doesn't make sense
+for normal users"*.
+
+The constraint behind it is real. A `FileSystemDirectoryHandle` never exposes a
+path, so the extension can read and write a folder while having no idea where it
+is — and a tab needs an absolute path to open a document. The only source was a
+document loading out of the folder and its content script reporting
+`sender.url`. Everything followed from treating that as the only source.
+
+**Chrome already knows.** If a document has ever been opened, its `file://` URL
+is in history. One `chrome.history.search({ text: '.bento.html' })` yields the
+absolute path of every Bento document the user has, which places every granted
+folder at once, with no trip to Finder.
+
+**The permission is optional, requested by a button, and handed straight back.**
+"Read your browsing history" is a heavy ask and a fair thing to balk at on a
+store listing, so it is not in `permissions`. It is in `optional_permissions`,
+requested at the moment it is needed with the reason on screen, and
+`permissions.remove`d in a `finally` — held for the length of one query.
+Declining is a legitimate answer and gets the manual route, said plainly,
+without asking again.
+
+**Nothing from history is trusted.** A URL is a hint. `route.js prefixFor`
+accepts a path only when the route resolves inside the grant AND `dir.resolve()`
+on what it lands on agrees with the path's own tail — the same check that stops
+a same-named file elsewhere from being written. The failure mode of getting this
+wrong is not a broken link: it is a folder recorded at the wrong location, with
+every document in it silently opening something else. Its rig is mostly refusals
+for that reason.
+
+`locateIn`/`pathFromSender` moved into `route.js` so the worker and the pages
+can both place a path. Importing `background.js` into a page instead would have
+registered a second `onMessage` listener there.
+
+### What this says about the process
+
+The chicken-and-egg was noticed and "fixed" twice — first by learning on save,
+then by learning on open — and both times the fix was inside the frame that
+opening a document is the only way to learn a path. Neither attempt asked
+whether the frame was true. The user did not report a bug; they reported that
+the result made no sense, which is the question that broke the frame.
+
+The rigs were green throughout. They test what the code does, and the code did
+what it was written to do.
+
+*2026-08-15.* "Can't the extension just inspect files to see if they're Bento?"
+Yes — and the better question was "why are there any misnamed ones?"
+
+**The listing now decides by CONTENT.** `id="bento-doc"` is the splice contract
+every Bento app honours (PLATFORM.md §2), frozen because old updaters depend on
+it, and it sits ~6KB into a real shell. So an unrecognised `.html` is settled by
+one 64KB read; a properly named document costs no read at all; the verdict is
+cached by size and mtime, so a second listing opens no bytes; and sniffing is
+capped per listing, because a granted home directory can hold thousands of
+unrelated pages.
+
+Marked in the UI rather than silently half-supported. A found-by-content
+document lists and opens, but the bridge that saves in place is a content script
+matching `file:///*.bento.html`, so it will still ask where to put itself. A
+tray that looked like it fully supported a document it half supports is a trap.
+
+**But the real fix was upstream, and Bento was the culprit.** `suggestedFileName`
+has always produced `.bento.html` — while the PICKER accepted `.html`. So an
+author who edited the name to "Q3" got `Q3.html`, and that document is a
+second-class citizen everywhere the convention is what identifies us: the webext
+bridge matches on the compound extension, and tray/ios matches the same way.
+Bento was manufacturing the exception and then being asked to cope with it.
+
+Both pickers now accept only `.bento.html`, so the browser appends it to a bare
+name. Compound suffixes are explicitly legal (`.tar.gz` is the spec's own
+example) and the limit is 16 characters against this one's 11 — checked in the
+spec rather than assumed, after a day of assuming browser behaviour and being
+wrong.
+
+The cost is that typing `deck.html` yields `deck.html.bento.html`. Accepting
+both extensions would remove that and also remove the whole benefit, since
+`.html` would again be a valid terminal suffix and nothing would be appended.
+The common case — typing a plain name — now produces the right thing, and the
+odd case produces a clumsy name rather than a broken one.
+
+**Widening the content-script match was considered and NOT done.** Making
+renamed documents save in place needs `file:///*.html`, which injects the bridge
+into every local page a user opens — a much heavier ask on a store listing than
+the narrow match, for a case that should now be rare because the source of it is
+fixed. If it is ever wanted, the pattern is the one the history search
+established: an optional permission, requested with the reason on screen,
+registering the broader script only when granted.
+
+*Found while writing the rig:* its `deps` lacked a cache, so `sniff` threw
+straight into a `catch { continue }` — the check reported green while proving
+nothing. Then the cache assertion counted `getFile()` calls, which a cache hit
+still makes (it needs size and mtime for the key); it now counts content reads.
+Two rounds of a test that passed for reasons unrelated to the thing under test.
+
+*2026-08-15.* A UX and UI pass before merging, and the diagnosis was structural
+rather than cosmetic.
+
+**Three surfaces, three design languages.** The home page had tokens and dark
+mode. The popup had 21 hardcoded colours and no dark mode. The options page had
+16 and no dark mode. So the surface people actually open — the popup — was the
+one that turned white at midnight, and the settings page looked like a different
+product reached by leaving the one you were in.
+
+`ui.css` now owns the palette and the shared primitives; each page keeps only
+its own layout. `pack-webext` fails on a literal colour anywhere but there
+(`setBadgeBackgroundColor` exempt: a browser API taking a string, which CSS
+variables cannot reach). Verified as a real gate by planting one.
+
+**Settings became a VIEW, and options.html is gone.** Same shell, same sidebar,
+same navigation. What was prose is now rows, because a folder is a thing with a
+state and an action and a paragraph about it is neither. `options_page` points
+at `home.html`, so `openOptionsPage()` still works from the popup.
+
+**The first run is steps, not an apology.** Both things that must happen are
+outside the extension's power — a folder you choose, and a Chrome switch no
+extension may touch — so it shows a short list with what is already done ticked,
+rather than an empty page explaining why nothing works.
+
+**Documents say which Bento they are.** Three apps write `.bento.html`, and the
+UI never said which one a document was, so a folder of decks, notes and sheets
+read as one undifferentiated pile. `describe` now reports the format field and
+the card carries a badge — alongside the `.html` badge for a document found by
+content rather than by name. Both sit on the picture, never in the body, so they
+cannot push a title around.
+
+**The notices were essays.** Each is now a sentence and, where there is
+something to do, a button. The reason a thing cannot be automated is interesting
+to us and not to someone trying to save a document.
+
+*Found by looking:* `.step b { display: block }` was unscoped, so a bolded phrase
+in the middle of a note became its own line and broke the sentence around it.
+Only visible in a screenshot — no rig would ever have caught it, and I had
+written the markup that triggered it.
+
+*2026-08-15.* Where the popup belongs, once the toolbar icon opens the library.
+
+**`default_popup` and `action.onClicked` are mutually exclusive.** Declaring a
+popup means the click opens it and the listener never fires. So wanting the icon
+to open the full page means having no popup at all — and the question becomes
+what the tray's compact form is FOR.
+
+**Its job was always switching documents while working in one**, and a popup is
+the wrong container for that: it dies the moment it loses focus, which is the
+moment you click into the thing you switched to. A **side panel** does not. Same
+markup, same code, better container — `sidePanel.open()` arrived in Chrome 116,
+which is this extension's floor exactly.
+
+Two surfaces, two jobs, and neither is a lesser copy of the other:
+
+- **toolbar click → the library.** Browsing and managing: folders, search,
+ rename, settings. Wants room and a tab that stays. An existing tab is FOCUSED
+ rather than duplicated.
+- **`Alt+B`, or right-click inside a document → the panel.** Switching while
+ working. Sits beside the document instead of vanishing.
+
+**`sidePanel.open()` must be called SYNCHRONOUSLY inside the gesture.** An
+`await` before it — even a trivial one — loses the gesture and Chrome refuses,
+silently. So the command handler reads nothing first; the panel decides what to
+show once it is up. The rig pins this by slicing the handler and asserting no
+`await` appears in it.
+
+For the same reason the lapsed-grant notification leads to the LIBRARY rather
+than the panel: it is handled after an await, so `sidePanel.open()` there would
+be refused without saying so. It used to try `chrome.action.openPopup()`, which
+no longer exists to try.
+
+`window.close()` is gone from the panel. A popup closing itself after an action
+is correct; a side panel doing it takes away the thing the user just used.
+
+*Two rig lessons, both mine.* The first gate for "nothing calls openPopup"
+matched the comment explaining why the call was removed — a gate that trips on
+its own documentation gets deleted rather than fixed, so it now strips comments
+and reads code. And it was verified by re-adding a real call and watching it
+fail, which is the only way to know a source gate is a gate.
+
+*2026-08-15.* Keeping unpacked installs current, when the browser will not.
+
+**Store installs update themselves; an unpacked one never does.** Chrome ignores
+`update_url` for a development install — it runs from a directory on disk and
+nothing is going to rewrite that directory. Self-hosting a `.crx` is not a way
+round it either: Chrome refuses off-store installs on Windows and macOS. So the
+only move available is to TELL those users.
+
+**Ask only the people it applies to.** `chrome.management.getSelf()` reports
+`installType`, and — checked in the API docs rather than assumed — it needs **no
+permission at all**, so this costs nothing on a listing. Anything but `normal`
+is told: `development` is the GitHub route this exists for, and
+`sideload`/`admin`/`other` also arrive outside the store's update mechanism. A
+store install is never asked and never makes the request; a notice about a
+version the browser has already installed is how an extension gets uninstalled.
+
+**A GET for a static JSON file, and nothing else.** No identifiers, no query
+string, no version reported upward — the comparison happens locally. The app's
+own update check promises "no ids, no telemetry", and the extension must not be
+quietly weaker. It can report and link; there is no mechanism for an unpacked
+extension to update itself, and inventing one would mean downloading code and
+asking for trust, which is precisely what a reviewer would ask about.
+
+**Not on the badge.** The badge means "a folder lapsed, saving will prompt". A
+version behind is neither urgent nor broken, so it is a notice in the library and
+a row in Settings, with a manual "Check now".
+
+**The digest is emitted, not typed.** `pack-webext` now writes
+`dist/tray-release.json` beside the zip, carrying the sha256 of the bytes it just
+built. A hand-copied hash goes stale in silence. Publishing it is worth
+something only because the package is byte-reproducible: anyone can rebuild from
+source and confirm the zip they downloaded is the one that was reviewed — the
+only verification available when the browser is not the thing doing the updating.
+
+**Startup only, plus a manual check.** A daily poll would cost the `alarms`
+permission for a courtesy. A browser session is the natural granularity for
+something whose remedy is "download and reload".
+
+*Rig note:* the comparison is numeric, not textual — `1.0.10` against `1.0.9` is
+the case string comparison gets backwards, and it is pinned. So is the direction
+that matters most: a store install is never told, and never even asks.
+
+*Amended, same day.* Should the check be automatic by default?
+
+Yes, but only with a switch and a disclosure — and the argument runs both ways
+inside this repo, which is why it is worth writing down.
+
+FOR: `kernel/src/update.ts` checks a release manifest at launch by default, with
+an off switch in the About dialog. The extension behaving differently would be
+an inconsistency with no reasoning behind it. And an unpacked install has no
+other way to find out it is behind: the browser will never tell it.
+
+AGAINST: the v0.9.1 fix exists precisely so an anonymous visitor never phones
+home without opting in, and the audience that loads an extension unpacked from
+GitHub is the audience most likely to object to a silent outbound request.
+
+The distinction that settles it: that fix was about connecting to a relay with
+document data. This is a static GET with no identifiers, no query string and no
+version reported upward. Different in kind — but "different in kind" is a
+judgement the user is entitled to make instead of us, so the preference sits in
+Settings next to what it does.
+
+OFF means NO REQUEST, not a request whose result is hidden. The rig pins that
+distinction, because the lazy implementation of a privacy switch is the one that
+keeps the traffic and quietens the UI.
+
+**Check now** works regardless: pressing a button is the consent the preference
+otherwise stands in for. And an unreadable preference is treated as ON, matching
+"absent means on" — a storage hiccup should not silently disable something the
+user never turned off.
+
+*Amended, same day.* What actually happens when an unpacked user acts on the
+notice — and the footgun the first version of the copy walked them into.
+
+**An unpacked extension is identified by its DIRECTORY PATH.** So the obvious
+upgrade — extract the new zip somewhere convenient, "Load unpacked" from there —
+produces a different extension: different id, different origin, empty
+IndexedDB. No granted folders, no learned prefixes, no preferences, and the old
+copy still installed beside it. The user has done the natural thing and lands on
+the first-run screen wondering where everything went.
+
+The original notice said "get it on GitHub and reload it in chrome://extensions",
+which is close enough to sound complete and does not contain the one word that
+matters: SAME folder. It is now three numbered steps, and step 2 says why.
+
+**The first-run screen also carries the warning**, because "an unpacked install
+with no folders" is precisely what a botched upgrade looks like from inside the
+new copy — and nothing there can detect it. The data is intact under the old id,
+which is still installed; the fix is to replace the files in the original folder
+and reload. Saying so on the screen the mistake produces is the only place it
+can be said.
+
+Not fixable any other way: handles cannot leave their origin, so there is no
+export/import that would carry grants across ids. The instruction is
+load-bearing, which is why it is in the notice, the first-run screen, the README
+and the store listing rather than in one of them.
+
+*2026-08-15.* Search reached the title, the file name and the folder — which
+finds a document you can already name. What people actually remember is a phrase
+ON a slide, and the bytes to answer that were already being read for the
+thumbnail and thrown away.
+
+`describe` now extracts the text in the same pass. Deliberately NOT a JSON
+parse: the block runs to megabytes with images inline, each app shapes it
+differently (slides put prose in `element.html`, spaces in blocks, dash in
+cells), and a reader that must know the format breaks when the format moves.
+Pulling string VALUES — `:"…"`, never keys — is format-agnostic and degrades to
+"finds less" rather than throwing. Data URIs are dropped first: one embedded
+image outweighs every word in a document. Capped at 40KB, so a folder of large
+documents does not quietly become a search index. Encrypted documents are never
+indexed — a searchable copy of a password-protected file is the leak the
+password prevents.
+
+Measured on a real deck: 36KB of prose out of a 900KB file, finding words from
+slide bodies and speaker notes.
+
+**Onboarding, help and about are one view, not three.** They are the same three
+questions — what is this, how do I use it, who made it — asked at different
+moments, and three surfaces would repeat each other and drift. It shows LIVE
+state rather than a leaflet: the two prerequisites tick themselves off, so the
+page that explains the product is also the page to return to when something
+stopped working, which is when people look for help. A fresh install is sent
+here by `onInstalled` with `reason === "install"` only — an update must not
+steal a tab, and reloading an unpacked extension fires that event every time.
+
+*Found by looking, twice:* `.tour b { display: block }` turned a bolded phrase
+mid-sentence into its own line — the identical mistake `.step b` had made and
+which I had already fixed. An unscoped element selector inside a component is
+the shape of the bug; both are now `> b`.
diff --git a/kernel/src/app.ts b/kernel/src/app.ts
index 197eaf5b..a00f4c60 100644
--- a/kernel/src/app.ts
+++ b/kernel/src/app.ts
@@ -31,6 +31,40 @@ let config: AppConfig | null = null
/** Called once at boot, before kernel modules are used. */
export function configureApp(cfg: AppConfig): void {
config = cfg
+ announceRuntime()
+}
+
+declare const __APP_VERSION__: string
+
+/**
+ * Tell a HOST which Bento runtime this document carries.
+ *
+ * A host that polyfills `showSaveFilePicker` (tray/webext) must know whether
+ * this document is old enough to predate `pickerIdFor` (#213). Before that,
+ * every save — including "Save a copy…" — sent `bento-doc`, so acting on the id
+ * there overwrites the open document. The host therefore refuses to write in
+ * place unless the runtime says it is at least 1.0.15.
+ *
+ * It used to read that from `window.bento.updates.version`, which each app
+ * assembles by hand — and **bento/dash does not include `updates` at all**, so
+ * every ⌘S in Dash fell back to a destination prompt even with a folder
+ * granted. The bug is not that Dash forgot; it is that the signal lived in a
+ * per-app object at all. Every app calls `configureApp`, so the version is
+ * announced here, once, and the next app gets it without knowing this exists.
+ *
+ * Deliberately a plain string on `window`, not a getter or an object: a host
+ * reads it from the page's world through a content script, and the simplest
+ * possible value is the one least likely to be mangled crossing that boundary.
+ */
+function announceRuntime(): void {
+ try {
+ const v = typeof __APP_VERSION__ !== 'undefined' ? __APP_VERSION__ : '0.0.0'
+ Object.defineProperty(window, '__bentoRuntime', {
+ value: v, writable: false, configurable: true, enumerable: false,
+ })
+ } catch {
+ /* already defined (a second configureApp in tests), or no window at all */
+ }
}
/** The active app config. Throws if the app forgot to configure itself —
diff --git a/kernel/src/save.ts b/kernel/src/save.ts
index c238b027..b48f4b86 100644
--- a/kernel/src/save.ts
+++ b/kernel/src/save.ts
@@ -604,7 +604,21 @@ async function pickHandle(
// update onwards opens where the first one saved.
...(fileHandle ? { startIn: fileHandle } : {}),
id: pickerIdFor(purpose),
- types: [{ description: appConfig().appName, accept: { 'text/html': ['.html'] } }],
+ // `.bento.html`, NOT `.html`, and the compound extension is the point.
+ //
+ // `suggestedFileName` has always produced `.bento.html`, but the picker
+ // accepted `.html` — so an author who edited the name to "Q3" got
+ // `Q3.html`, and a document named that is a second-class citizen
+ // everywhere the convention is what identifies us: tray/webext injects
+ // its save bridge on `file:///*.bento.html`, so such a file opens fine
+ // and then asks where to save, and tray/ios matches the same way.
+ //
+ // Bento was manufacturing the exception and then being asked to cope with
+ // it. Accepting only the compound extension means the browser appends it
+ // to a bare name, which is what everybody meant. Compound suffixes are
+ // explicitly legal here (`.tar.gz` is the spec's own example) and the
+ // limit is 16 characters against this one's 11.
+ types: [{ description: appConfig().appName, accept: { 'text/html': ['.bento.html'] } }],
})
} catch (err: any) {
if (err?.name === 'AbortError') return null
@@ -764,7 +778,7 @@ export async function writeBackupBeside(html: string, name: string): Promise<'be
const handle = await (window as any).showSaveFilePicker({
suggestedName: name,
id: pickerIdFor('backup'),
- types: [{ description: appConfig().appName, accept: { 'text/html': ['.html'] } }],
+ types: [{ description: appConfig().appName, accept: { 'text/html': ['.bento.html'] } }],
})
if (handle) {
await writeHandle(handle, html)
diff --git a/scripts/pack-webext.mjs b/scripts/pack-webext.mjs
index 8625004f..e4c9cc53 100644
--- a/scripts/pack-webext.mjs
+++ b/scripts/pack-webext.mjs
@@ -33,13 +33,23 @@ import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'n
import { join, dirname, relative } from 'node:path'
import { fileURLToPath } from 'node:url'
import { deflateRawSync, crc32 } from 'node:zlib'
+import { createHash } from 'node:crypto'
const root = join(dirname(fileURLToPath(import.meta.url)), '..')
const SRC = join(root, 'tray/webext')
const OUT = join(root, 'dist')
/** What ships. Anything in the tree and not matched here is an error. */
-const INCLUDE = [/^manifest\.json$/, /^icons\/[^/]+\.png$/, /^src\/[^/]+\.(js|html)$/]
+// The PNGs are the toolbar action icon, which Chrome composites into its own
+// chrome at fixed sizes. The SVG is the favicon for the extension's own pages —
+// one vector rather than a family of files, because a tab icon is drawn at 16px
+// and again at whatever the history and bookmarks views feel like.
+const INCLUDE = [
+ /^manifest\.json$/,
+ /^icons\/[^/]+\.(png|svg)$/,
+ /^src\/[^/]+\.(js|html|css)$/,
+ /^_locales\/[a-zA-Z_]+\/messages\.json$/,
+]
/** Present on purpose, deliberately NOT shipped. */
const EXCLUDE = [/^probe\//, /^README\.md$/, /^STORE\.md$/]
@@ -66,6 +76,73 @@ for (const rel of all) {
fail(`unexpected file in tray/webext — add it to INCLUDE or EXCLUDE deliberately: ${rel}`)
}
+// ---- the icons must have transparent corners -------------------------------
+// The shipped PNGs had NO ALPHA CHANNEL: RGB, not RGBA, so opaque squares by
+// construction, and the toolbar showed a hard square no CSS could round. They
+// are exports of icons/icon.svg, and an export that quietly drops the alpha
+// looks identical in a file listing and square in the browser — the kind of
+// regression nobody sees until it ships.
+//
+// Colour type lives at byte 25 of a PNG: 8-byte signature, then IHDR's length
+// and type (8 more), then width, height, bit depth, and colour type. 6 is
+// truecolour with alpha, 4 is greyscale with alpha; anything else has none.
+function pngColourType(abs) {
+ const head = readFileSync(abs).subarray(0, 26)
+ if (head.length < 26 || head.readUInt32BE(0) !== 0x89504e47) return null
+ return head[25]
+}
+for (const rel of all.filter((r) => /^icons\/.*\.png$/.test(r))) {
+ const ct = pngColourType(join(SRC, rel))
+ if (ct === null) { fail(`${rel} is not a PNG`); continue }
+ if (ct !== 6 && ct !== 4) {
+ fail(`${rel} has no alpha channel (colour type ${ct}) — its corners are opaque, `
+ + 'so the rounded mark will render as a square. Re-export from icons/icon.svg.')
+ }
+}
+
+// ---- a shipped SVG must actually parse -------------------------------------
+// It did not. `icon.svg` carried its own regeneration command in an XML comment,
+// and every flag in that command starts with a double hyphen — which an XML
+// comment may not contain. The file was malformed, so the mark rendered as a
+// broken image on every surface that used it, while looking perfectly correct
+// in an editor and passing every other check here.
+//
+// No XML parser in node's standard library, so this checks the one rule that
+// was broken plus the shape of the thing: a comment with `--` inside it, and a
+// root element that opens and closes.
+for (const rel of payload.filter((p) => p.endsWith('.svg'))) {
+ const text = readFileSync(join(SRC, rel), 'utf8')
+ for (const m of text.matchAll(/<!--([\s\S]*?)-->/g)) {
+ if (m[1].includes('--')) {
+ fail(`${rel} has a comment containing "--", which is not valid XML — the file will not `
+ + 'parse and the image will not render. Command line flags belong in the README.')
+ }
+ }
+ if (!/<svg[\s>]/.test(text) || !/<\/svg>/.test(text)) fail(`${rel} has no <svg> root element`)
+}
+
+// ---- one design system, not three ------------------------------------------
+// There were three: the home page had tokens and dark mode, the popup had 21
+// hardcoded colours and no dark mode, the options page had 16 and no dark mode —
+// the same product in three costumes, and the surface people actually open was
+// the one that turned white at midnight.
+//
+// ui.css owns the palette. A literal colour anywhere else is how that comes
+// back, one convenient hex at a time, and the symptom is a page that ignores
+// dark mode rather than anything that looks broken in review.
+//
+// `chrome.action.setBadgeBackgroundColor` is exempt: it is a browser API taking
+// a colour string, not a stylesheet, and CSS variables cannot reach it.
+for (const rel of payload.filter((p) => /\.(html|js)$/.test(p) && p !== 'src/ui.css')) {
+ const text = readFileSync(join(SRC, rel), 'utf8')
+ for (const line of text.split('\n')) {
+ if (!/#[0-9a-fA-F]{3,8}\b/.test(line)) continue
+ if (/setBadgeBackgroundColor/.test(line)) continue
+ if (/^\s*(\*|\/\/|<!--)/.test(line)) continue // prose about colours is fine
+ fail(`${rel} has a literal colour — the palette lives in ui.css: ${line.trim().slice(0, 72)}`)
+ }
+}
+
// ---- the manifest must match the tree --------------------------------------
let manifest = null
try {
@@ -74,21 +151,79 @@ try {
fail(`manifest.json does not parse: ${e.message}`)
}
+// ---- localisation ----------------------------------------------------------
+// The store shows `name` and `description` in the shopper's language, so those
+// are `__MSG_*__` placeholders resolved from `_locales`. Which means the checks
+// below MUST resolve them first: a length check against the literal string
+// "__MSG_appDesc__" passes happily while the real German description runs 40
+// characters over and gets truncated in the listing.
+const messagesFor = (loc) => {
+ try {
+ return JSON.parse(readFileSync(join(SRC, `_locales/${loc}/messages.json`), 'utf8'))
+ } catch {
+ return null
+ }
+}
+const localeDirs = [...new Set(all
+ .filter((r) => r.startsWith('_locales/'))
+ .map((r) => r.split('/')[1]))]
+
+let resolve = (v) => v
+if (manifest && localeDirs.length) {
+ const def = manifest.default_locale
+ if (!def) fail('there is a _locales directory, so the manifest must set "default_locale"')
+ const base = def ? messagesFor(def) : null
+ if (def && !base) fail(`default_locale is "${def}" but _locales/${def}/messages.json is missing or invalid`)
+
+ resolve = (v, loc = def) => String(v ?? '').replace(/__MSG_([A-Za-z0-9_]+)__/g, (whole, key) => {
+ const m = messagesFor(loc)?.[key]?.message
+ return m ?? whole
+ })
+
+ for (const loc of localeDirs) {
+ const msgs = messagesFor(loc)
+ if (!msgs) { fail(`_locales/${loc}/messages.json does not parse`); continue }
+ for (const [key, entry] of Object.entries(msgs)) {
+ if (typeof entry?.message !== 'string' || !entry.message) {
+ fail(`_locales/${loc}/messages.json: "${key}" has no message`)
+ }
+ }
+ }
+
+ // Every placeholder the manifest uses must exist in the DEFAULT locale, or
+ // the store sees the raw "__MSG_appName__" as the extension's name.
+ for (const field of ['name', 'description']) {
+ const raw = manifest[field] ?? ''
+ for (const m of String(raw).matchAll(/__MSG_([A-Za-z0-9_]+)__/g)) {
+ if (!base?.[m[1]]) fail(`manifest.${field} uses __MSG_${m[1]}__ but the default locale does not define it`)
+ }
+ }
+
+ // And the LISTING strings are checked in every locale, because a description
+ // is only useful where it is read.
+ for (const loc of localeDirs) {
+ const desc = resolve(manifest.description, loc)
+ if (desc.startsWith('__MSG_')) continue // falls back to default: fine
+ if (desc.length > 132) fail(`${loc} description is ${desc.length} chars; the store truncates at 132`)
+ }
+}
+
if (manifest) {
if (manifest.manifest_version !== 3) fail('manifest_version must be 3')
for (const k of ['name', 'version', 'description']) {
if (!manifest[k]) fail(`manifest is missing "${k}" — the store requires it`)
}
if (manifest.version === '0.0.1') fail('manifest version is still the scaffold placeholder 0.0.1')
- if ((manifest.description ?? '').length > 132) {
- fail(`description is ${manifest.description.length} chars; the store truncates at 132`)
- }
+ const desc = resolve(manifest.description)
+ if (desc.length > 132) fail(`description is ${desc.length} chars; the store truncates at 132`)
+ if (desc.startsWith('__MSG_')) fail('manifest.description does not resolve — check _locales')
const named = new Set()
const claim = (p) => { if (p) named.add(p.replace(/^\//, '')) }
claim(manifest.background?.service_worker)
claim(manifest.options_page)
claim(manifest.action?.default_popup)
+ claim(manifest.side_panel?.default_path)
for (const cs of manifest.content_scripts ?? []) (cs.js ?? []).forEach(claim)
for (const size of ['16', '32', '48', '128']) {
const p = manifest.icons?.[size]
@@ -189,3 +324,25 @@ const out = join(OUT, `bento-tray-${manifest.version}.zip`)
writeFileSync(out, bytes)
console.log(`\nwrote ${relative(root, out)} — ${(bytes.length / 1024).toFixed(1)}KB`)
console.log('deterministic: the same tree always produces these bytes')
+
+// ---- the release manifest unpacked installs read ---------------------------
+// A store install updates itself. One loaded unpacked never will — Chrome
+// ignores `update_url` for a development install — so the extension asks this
+// file whether it is behind (src/update.js) and says so. Emitted here rather
+// than written by hand because the digest has to match the bytes just built,
+// and a hand-copied hash is a hash that goes stale silently.
+//
+// The digest is publishable BECAUSE the zip is reproducible: anyone can rebuild
+// from source and confirm the package they downloaded is the package that was
+// reviewed. That is the only verification available when the browser is not the
+// one doing the updating.
+const digest = createHash('sha256').update(bytes).digest('hex')
+const release = {
+ version: manifest.version,
+ url: `https://github.com/nyblnet/bento/releases/tag/tray-v${manifest.version}`,
+ sha256: digest,
+}
+const relOut = join(OUT, 'tray-release.json')
+writeFileSync(relOut, `${JSON.stringify(release, null, 2)}\n`)
+console.log(`wrote ${relative(root, relOut)} — publish at /releases/tray/manifest.json`)
+console.log(`sha256 ${digest}`)
diff --git a/scripts/test-savepurpose.ts b/scripts/test-savepurpose.ts
index 0aefe463..93241300 100644
--- a/scripts/test-savepurpose.ts
+++ b/scripts/test-savepurpose.ts
@@ -19,7 +19,7 @@
// out the way we did.
import { readFileSync } from 'node:fs'
-import { pickerIdFor, type SavePurpose } from '../kernel/src/save.ts'
+import { pickerIdFor, suggestedFileName as suggestedName, type SavePurpose } from '../kernel/src/save.ts'
let failures = 0
let checks = 0
@@ -54,6 +54,22 @@ ok(ids.every((id) => /^[a-z0-9-]+$/.test(id) && id.length <= 32),
//
// Read as source, because the branch is unreachable without a DOM and a picker.
// A weak assertion on the right line beats a strong one on a mock of it.
+
+// ------------------------------------------------- every app announces itself
+// A host must know whether a document predates `pickerIdFor` (#213), because
+// before it every save sent `bento-doc` and acting on that overwrites the open
+// document. The signal used to live in `window.bento.updates.version`, which
+// each app assembles by hand — and bento/dash never included `updates`, so
+// every Cmd-S in Dash fell through to a destination prompt. The fix is that the
+// signal cannot live in a per-app object at all: `configureApp` is the one call
+// every app makes, so it announces the version and the next app inherits it.
+const appSrc = readFileSync(new URL('../kernel/src/app.ts', import.meta.url), 'utf8')
+ok(/__bentoRuntime/.test(appSrc), 'the kernel announces the runtime version to a host')
+ok(appSrc.indexOf('announceRuntime()') < appSrc.indexOf('function announceRuntime'),
+ 'and does it from configureApp, which every app calls — not from each app in turn')
+ok(/writable: false/.test(appSrc),
+ 'the announcement is not writable: a document shares that realm and must not fake its own version')
+
const updateSrc = readFileSync(new URL('../kernel/src/update.ts', import.meta.url), 'utf8')
const call = updateSrc.slice(updateSrc.indexOf('writeUpdatedFileAs(html'))
ok(/purpose:\s*'in-place'/.test(call.slice(0, 300)),
@@ -61,5 +77,27 @@ ok(/purpose:\s*'in-place'/.test(call.slice(0, 300)),
ok(!/writeUpdatedFileAs\(html, doc, \{ keepHandle: true, suggestedName: [^}]*\}\)/.test(updateSrc),
'the update no longer falls through to the default share purpose')
+// ------------------------------------------------- the convention is the id
+// `.bento.html` is not decoration. tray/webext injects its save bridge on
+// `file:///*.bento.html` and tray/ios matches the same way, so a document named
+// `Q3.html` opens fine and then asks where to save — it is a second-class
+// citizen everywhere the name is what identifies us.
+//
+// `suggestedFileName` has always produced the compound extension, but the
+// PICKER accepted `.html`, so an author who typed a bare name got `Q3.html`.
+// Bento was manufacturing the exception and then coping with it. Accepting only
+// `.bento.html` makes the browser append it to a bare name.
+const saveSrc = readFileSync(new URL('../kernel/src/save.ts', import.meta.url), 'utf8')
+ok(/\.bento\.html$/.test(suggestedName({ title: 'Q3 Board Review' } as any)),
+ `suggestedFileName produces the compound extension (${suggestedName({ title: 'Q3 Board Review' } as any)})`)
+ok(!/accept: \{ 'text\/html': \['\.html'\] \}/.test(saveSrc),
+ 'and the picker no longer accepts a bare .html, which is how bare names slipped through')
+for (const m of saveSrc.matchAll(/accept: \{ 'text\/html': \[([^\]]*)\] \}/g)) {
+ ok(m[1] === "'.bento.html'", `every picker accepts only .bento.html (found ${m[1]})`)
+}
+ok((saveSrc.match(/accept: \{ 'text\/html'/g) ?? []).length >= 2,
+ 'both picker call sites are covered — a copy that drifts is how one of them would regress')
+
+
console.log(`\n${checks - failures}/${checks} checks passed`)
if (failures) process.exit(1)
diff --git a/scripts/test-webext-background.ts b/scripts/test-webext-background.ts
index 02d8bbec..1be8139d 100644
--- a/scripts/test-webext-background.ts
+++ b/scripts/test-webext-background.ts
@@ -24,6 +24,7 @@
// Both are checked by construction here: a write is issued with no preceding
// claim at all, which is exactly what a service worker restart looks like.
+import { readFileSync } from 'node:fs'
import { pathFromSender, findByName, claim, write, resolve, backup, backupNameFor } from '../tray/webext/src/background.js'
let failures = 0
@@ -47,6 +48,10 @@ function fileHandle(name: string, rel?: string[]) {
kind: 'file' as const,
name,
__rel: rel ?? [name],
+ /** Identity, not equality: the real API answers "same file on disk?", which
+ * is how one file reached through two nested grants is told apart from two
+ * different files that merely share a name. */
+ async isSameEntry(other: any) { return other === this || other?.__id === (this as any).__id },
async createWritable() {
let buf = ''
return {
@@ -57,10 +62,14 @@ function fileHandle(name: string, rel?: string[]) {
}
}
-function dirHandle(tree: Record<string, any>, perm = 'granted', base: string[] = []) {
+// `base` is where this directory sits BELOW the grant root, which is what
+// resolve() reports. `rootName` is the grant's own folder name — the thing
+// locateIn matches against the sender's path, and the two are independent: a
+// grant named "Documents" has base [] and still has a name.
+function dirHandle(tree: Record<string, any>, perm = 'granted', base: string[] = [], rootName = 'Decks') {
return {
kind: 'directory' as const,
- name: base.at(-1) ?? 'Decks',
+ name: base.at(-1) ?? rootName,
async queryPermission() { return perm },
/** The real API: path segments from THIS directory down to `child`, or null. */
async resolve(child: any) {
@@ -104,7 +113,13 @@ ok(pathFromSender({ url: 'file:///Users/x/My%20Decks/Q3.bento.html' }) === '/Use
// ---- 2. resolution inside the grant ----------------------------------------
const deps = (tree: Record<string, any>, perm = 'granted') => ({
- readGrant: async () => dirHandle(tree, perm),
+ readGrants: async () => [dirHandle(tree, perm)],
+ findByName,
+})
+
+/** Several granted folders at once, each with its own permission state. */
+const multiDeps = (...grants: Array<{ tree: Record<string, any>; perm?: string; name?: string }>) => ({
+ readGrants: async () => grants.map((g) => dirHandle(g.tree, g.perm ?? 'granted', g.name ? [g.name] : [])),
findByName,
})
@@ -120,14 +135,23 @@ const deps = (tree: Record<string, any>, perm = 'granted') => ({
'a file outside the grant is declined, not guessed at')
}
{
- // the same name in two subfolders — the case a real Decks folder hits
+ // the same name in two subfolders — the case a real Decks folder hits.
+ //
+ // THIS USED TO DECLINE, and the decline was a limitation, not a safety
+ // property: the old code searched by filename, found both, and could not tell
+ // which one the sender was. Routing by path reaches exactly one, because only
+ // one route leads to it — and the identity check still verifies what it
+ // landed on. Anyone with client folders hit this on every save.
const tree = {
ClientA: { 'Q3.bento.html': fileHandle('Q3.bento.html', ['ClientA', 'Q3.bento.html']) },
ClientB: { 'Q3.bento.html': fileHandle('Q3.bento.html', ['ClientB', 'Q3.bento.html']) },
}
- const r = await resolve(senderFor('/Users/x/Decks/ClientA/Q3.bento.html'), deps(tree))
- ok(r.ok === false && /ambiguous/.test(r.reason!),
- 'a duplicate file name is declined rather than written to the wrong one')
+ const a = await resolve(senderFor('/Users/x/Decks/ClientA/Q3.bento.html'), deps(tree))
+ ok(a.ok === true && a.within === '/ClientA/Q3.bento.html',
+ 'two decks sharing a name both save — each to its own file, not declined')
+ const b = await resolve(senderFor('/Users/x/Decks/ClientB/Q3.bento.html'), deps(tree))
+ ok(b.ok === true && b.within === '/ClientB/Q3.bento.html',
+ 'and the other one resolves to the other file')
}
{
const tree = { 'Q3.bento.html': fileHandle('Q3.bento.html') }
@@ -223,7 +247,7 @@ const deps = (tree: Record<string, any>, perm = 'granted') => ({
['Other.v1-backup.bento.html', 'a name derived from a DIFFERENT file'],
['Q3.v1-backup.txt', 'a non-document extension'],
['Q3.v1 backup.bento.html', 'a name with a space'],
- ['Q3..bento.html', 'an embedded NUL'],
+ ['Q3.\u0000.bento.html', 'an embedded NUL'],
] as const) {
ok(backupNameFor(own, bad) === null, `${why} is refused (${JSON.stringify(bad)})`)
}
@@ -286,5 +310,228 @@ const deps = (tree: Record<string, any>, perm = 'granted') => ({
ok(written.size === 0, 'and nothing was written')
}
+// ---- 7. several granted folders --------------------------------------------
+// One folder was never the shape of anyone's work: decks live under clients,
+// under projects, on the Desktop. What matters is that adding folders does not
+// weaken the identity guarantee — every grant is tried, and the winner is still
+// verified against the sender's own path.
+{
+ const decks = { 'Q3.bento.html': fileHandle('Q3.bento.html') }
+ const work = { 'Plan.bento.html': fileHandle('Plan.bento.html') }
+ const r = await resolve(senderFor('/Users/x/Decks/Q3.bento.html'),
+ multiDeps({ tree: decks }, { tree: work }))
+ ok(r.ok === true && r.name === 'Q3.bento.html', 'a file in the FIRST granted folder resolves')
+}
+{
+ // a second folder with its own name — the ordinary two-folder case
+ const decks = { 'Q3.bento.html': fileHandle('Q3.bento.html') }
+ const work = { 'Plan.bento.html': fileHandle('Plan.bento.html') }
+ const grants = {
+ readGrants: async () => [dirHandle(decks, 'granted', [], 'Decks'), dirHandle(work, 'granted', [], 'Work')],
+ findByName,
+ }
+ const r = await resolve(senderFor('/Users/x/Work/Plan.bento.html'), grants)
+ ok(r.ok === true && r.name === 'Plan.bento.html', 'a file in the SECOND granted folder resolves')
+ const miss = await resolve(senderFor('/Users/x/Elsewhere/Other.bento.html'), grants)
+ ok(miss.ok === false && /not in the granted folder/.test(miss.reason!),
+ 'a file in neither folder is still declined')
+}
+{
+ // ONE lapsed grant must not mask the others — the failure that would make
+ // adding a folder look like breaking the extension
+ const decks = { 'Q3.bento.html': fileHandle('Q3.bento.html') }
+ const work = { 'Plan.bento.html': fileHandle('Plan.bento.html') }
+ const grants = {
+ readGrants: async () => [dirHandle(decks, 'prompt', [], 'Decks'), dirHandle(work, 'granted', [], 'Work')],
+ findByName,
+ }
+ const good = await resolve(senderFor('/Users/x/Work/Plan.bento.html'), grants)
+ ok(good.ok === true, 'a healthy grant still serves while another has lapsed')
+ const bad = await resolve(senderFor('/Users/x/Decks/Q3.bento.html'), grants)
+ ok(bad.ok === false && /renewing/.test(bad.reason!),
+ 'and a file in the lapsed one reports that it needs renewing, not that it is missing')
+}
+{
+ // nested grants: the same file reached by two routes is ONE file, not an
+ // ambiguity. isSameEntry is the only thing that can tell those apart.
+ // ONE file on disk, seen through two grants — so it presents as two handles
+ // with different relative paths but the same identity, which is exactly what
+ // Chrome does here.
+ const viaOuter = fileHandle('Q3.bento.html', ['Decks', 'Q3.bento.html'])
+ ;(viaOuter as any).__id = 'same-file'
+ const viaInner = fileHandle('Q3.bento.html')
+ ;(viaInner as any).__id = 'same-file'
+ const grants = {
+ readGrants: async () => [
+ dirHandle({ Decks: { 'Q3.bento.html': viaOuter } }, 'granted', [], 'Documents'),
+ dirHandle({ 'Q3.bento.html': viaInner }, 'granted', [], 'Decks'),
+ ],
+ findByName,
+ }
+ const r = await resolve(senderFor('/Users/x/Documents/Decks/Q3.bento.html'), grants)
+ ok(r.ok === true, 'a file inside two nested grants resolves rather than being called ambiguous')
+}
+{
+ // and two genuinely DIFFERENT files reachable at the same path is the case
+ // that must still decline
+ const a = fileHandle('Q3.bento.html'); (a as any).__id = 'A'
+ const b = fileHandle('Q3.bento.html'); (b as any).__id = 'B'
+ const grants = {
+ readGrants: async () => [
+ dirHandle({ 'Q3.bento.html': a }, 'granted', [], 'Decks'),
+ dirHandle({ 'Q3.bento.html': b }, 'granted', [], 'Decks'),
+ ],
+ findByName,
+ }
+ const r = await resolve(senderFor('/Users/x/Decks/Q3.bento.html'), grants)
+ ok(r.ok === false && /ambiguous/.test(r.reason!),
+ 'two different files reachable by the same route are declined, not guessed at')
+}
+{
+ // a grant with no folders at all
+ const r = await resolve(senderFor('/Users/x/Decks/Q3.bento.html'), { readGrants: async () => [], findByName })
+ ok(r.ok === false && /no folder granted/.test(r.reason!), 'no grants at all is reported as such')
+}
+
+// ---- 8. a big grant costs nothing to search --------------------------------
+// The point of routing rather than walking: granting a home directory has to be
+// as cheap as granting a decks folder, or "everywhere" is not offerable. This
+// counts DIRECTORY ENUMERATIONS — the thing that made a large grant unusable.
+{
+ let enumerations = 0
+ const wide: Record<string, any> = { Decks: { 'Q3.bento.html': fileHandle('Q3.bento.html', ['Decks', 'Q3.bento.html']) } }
+ for (let i = 0; i < 500; i++) wide[`junk${i}`] = { [`f${i}.txt`]: fileHandle(`f${i}.txt`) }
+ const counting = dirHandle(wide, 'granted', [], 'home')
+ const origEntries = counting.entries.bind(counting)
+ ;(counting as any).entries = async function* (...a: any[]) { enumerations++; yield* origEntries(...a) }
+ const r = await resolve(senderFor('/Users/x/home/Decks/Q3.bento.html'),
+ { readGrants: async () => [counting], findByName })
+ ok(r.ok === true, 'a file inside a 500-entry grant resolves')
+ ok(enumerations === 0, `and nothing was enumerated to find it (${enumerations} directory scans)`)
+}
+
+// ---- 9. the worker and the options page read the SAME store ----------------
+// They open IndexedDB independently — the service worker cannot import the
+// options page's module and vice versa — so the store name, the database name
+// and the KEYS are duplicated in two files. If they drift, the options page
+// writes grants the worker never sees: the UI says the folder is granted, every
+// save falls back to a picker, and nothing anywhere reports a problem.
+//
+// Source-level, because the two halves cannot be loaded into one realm to be
+// compared at runtime. A weak check on the real constants beats none.
+{
+ const read = (f: string) => readFileSync(new URL(`../tray/webext/src/${f}`, import.meta.url), 'utf8')
+ /** Source with comments removed, for gates that must not match documentation
+ * about the very thing they forbid. */
+ const codeOf = (t: string) => t.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '')
+ const bg = read('background.js')
+ const st = read('status.js')
+ const constOf = (src: string, name: string) => src.match(new RegExp(`const ${name} = '([^']+)'`))?.[1]
+
+ // This used to compare duplicated DB/STORE constants between the two files.
+ // They are gone: db.js owns the store and both halves import it. So the gate
+ // becomes the stronger statement — the duplication must not come BACK.
+ // A second `indexedDB.open` is how the split-brain returns, and its symptom
+ // is the options page writing grants the worker never reads: UI green, every
+ // save prompting, nothing reporting a fault.
+ const db = read('db.js')
+ ok(/indexedDB\.open/.test(db), 'db.js opens the database')
+ ok(!/indexedDB\.open/.test(bg) && !/indexedDB\.open/.test(st),
+ 'and nothing else does — one module owns the store')
+ ok(/from '\.\/db\.js'/.test(st), 'status.js reads the store through it')
+ ok(constOf(db, 'DB') === 'bento-tray', `the database name is stable (${constOf(db, 'DB')})`)
+ // Each key is named in the module that owns its meaning, not scattered:
+ // the grant list is status.js's business, the path prefixes are db.js's.
+ ok(st.includes("'dirs'") && st.includes("'dir'"),
+ "status.js owns the grant keys, including the legacy 'dir' still migrated")
+ ok(db.includes("'prefixes'"), "db.js owns the learned path prefixes")
+ ok(/VERSION = 2/.test(db) && /objectStoreNames\.contains/.test(db),
+ 'the version bump for the cache store is guarded, so a v1 install upgrades rather than throwing')
+}
+
+// ---- 10. the lapsed-grant badge stays wired --------------------------------
+// The badge is the only thing that reports a lapsed grant BEFORE a save falls
+// back to a picker. It is pure wiring — no return value, nothing downstream
+// reads it — so if the call is dropped nothing fails, and the symptom is
+// silence: saves start prompting again with no indication why. Source-level,
+// because chrome.action does not exist here.
+{
+ const read = (f: string) => readFileSync(new URL(`../tray/webext/src/${f}`, import.meta.url), 'utf8')
+ /** Source with comments stripped, for gates that must not match documentation
+ * about the very thing they forbid. */
+ const codeOf = (t: string) => t.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '')
+ const bg = read('background.js')
+ const st = read('status.js')
+ const pop = read('panel.js')
+
+ ok(/export async function setLapsedBadge/.test(st), 'status.js owns the badge rule')
+ ok(/setBadgeText/.test(st), 'and actually sets a badge')
+ ok(bg.includes('setLapsedBadge'), 'the worker refreshes the badge after handling a message')
+ ok(/onStartup/.test(bg), 'and on browser startup — where a dropped grant would first show')
+ ok(!/setBadgeText/.test(bg) && !/setBadgeText/.test(pop),
+ 'only status.js decides what "lapsed" means — the icon and the panel cannot disagree')
+ ok(/requestPermission/.test(pop),
+ 'the panel can raise the permission dialog itself, without a trip to settings')
+
+ // The chicken-and-egg that shipped: the tray lists documents by walking
+ // grants, but needs an absolute path to OPEN one, and that path was learned
+ // only during a save. So a fresh install listed everything and could open
+ // nothing. Opening a document is the natural moment to learn its folder.
+ const relay = read('relay.js')
+ ok(/op: 'hello'/.test(relay), 'the content script announces itself on load')
+ ok(/'hello'/.test(bg) && /learnPrefix/.test(bg),
+ 'and the worker resolves it, which is what records where that folder lives')
+ // The call itself, not the comment above it: the announcement must send only
+ // an op. A payload here would be page-controlled data arriving at the code
+ // that decides which file to write, which is the one thing this architecture
+ // refuses — the path comes from sender.url, stamped by the browser.
+ ok(/sendMessage\(\{\s*op:\s*'hello'\s*\}\)/.test(relay),
+ 'the announcement sends an op and nothing else — no page-controlled payload reaches the resolver')
+
+ // The notification is the ACTIVE half of reporting a lapse — the badge only
+ // reports to someone already looking at the toolbar. Same wiring risk: no
+ // return value, nothing reads it, so a dropped call is silent.
+ ok(/chrome\.notifications\?\.\.?create|chrome\.notifications\?\.create/.test(st)
+ || /notifications\.create/.test(st), 'status.js can raise a notification')
+ ok(bg.includes('reportLapsed') && /onStartup/.test(bg),
+ 'the worker reports a lapse on browser startup — before any save has failed')
+ ok(/storage\?\.session|storage\.session/.test(st),
+ 'and only once per browser session, which is the lifetime of a lapse')
+ ok(/onButtonClicked/.test(bg) && /onClicked/.test(bg),
+ 'both the notification body and its button lead somewhere')
+ // There is no popup any more: the toolbar opens the library and the tray is a
+ // side panel. A notification is handled after an await, which loses the user
+ // gesture sidePanel.open() requires, so it leads to the library instead —
+ // silently refused is the worst of both.
+ // Against CODE, not prose. The comment above the function explains why the
+ // call is gone and names it in full, so both "the word" and "call-shaped"
+ // match the documentation — a gate that trips on its own explanation gets
+ // deleted rather than fixed.
+ ok(!/\.openPopup\s*\(/.test(codeOf(st)), 'nothing still calls chrome.action.openPopup')
+ ok(/home\.html/.test(st), 'the notification leads to the library, which carries the same repair')
+
+ const manifest = JSON.parse(readFileSync(new URL('../tray/webext/manifest.json', import.meta.url), 'utf8'))
+ ok(manifest.permissions?.includes('notifications'),
+ 'the manifest asks for the notifications permission the code depends on')
+ // default_popup and onClicked are mutually exclusive: declaring a popup means
+ // the click opens it and the listener never runs. The click must open the
+ // library, so there must be no popup.
+ ok(!manifest.action?.default_popup,
+ 'no default_popup, or chrome.action.onClicked would never fire')
+ ok(manifest.side_panel?.default_path === 'src/panel.html',
+ 'the tray is declared as a side panel')
+ ok(!!manifest.commands?.['open-panel']?.suggested_key,
+ 'and has a keyboard shortcut, which is the gesture sidePanel.open() needs')
+ for (const perm of ['sidePanel', 'contextMenus']) {
+ ok(manifest.permissions?.includes(perm), `the manifest asks for "${perm}"`)
+ }
+ ok(/onClicked/.test(bg) && /sidePanel\.open/.test(bg),
+ 'the worker opens the library on click and the panel on its own gestures')
+ // sidePanel.open() must be called SYNCHRONOUSLY inside the gesture. An await
+ // before it loses the gesture and Chrome refuses, without saying so.
+ const cmd = bg.slice(bg.indexOf("command !== 'open-panel'"), bg.indexOf("command !== 'open-panel'") + 320)
+ ok(!/await/.test(cmd), 'and does it synchronously — an await first loses the user gesture')
+}
+
console.log(`\n${checks - failures}/${checks} checks passed`)
if (failures) process.exit(1)
diff --git a/scripts/test-webext-bridge.ts b/scripts/test-webext-bridge.ts
index d22cc5d0..2d67fb96 100644
--- a/scripts/test-webext-bridge.ts
+++ b/scripts/test-webext-bridge.ts
@@ -94,6 +94,38 @@ for (const [id, shouldDefer] of [
p.catch(() => {})
}
+// ---- the runtime version can come from EITHER source ------------------------
+// It used to come only from `window.bento.updates.version`, which every app
+// assembles by hand — and bento/dash never included `updates`, so every Cmd-S
+// in Dash fell through to a destination prompt with a folder granted and
+// nothing saying why. The kernel now announces `__bentoRuntime` from
+// configureApp, which every app calls. Both must work: the announcement for
+// everything built from now on, the hand-made object for every document already
+// shipped.
+{
+ const { win, nativeCalls } = load({})
+ ;(win as any).__bentoRuntime = '1.0.17' // kernel-announced, no window.bento at all
+ win.showSaveFilePicker({ id: 'bento-doc', suggestedName: 'Q3.bento.html' }).catch(() => {})
+ await new Promise((r) => setTimeout(r, 0))
+ ok(nativeCalls.length === 0,
+ 'a document announcing __bentoRuntime saves in place even with no window.bento — the Dash case')
+}
+{
+ const { win, nativeCalls } = load({ version: '1.0.17' }) // shipped shape, no announcement
+ win.showSaveFilePicker({ id: 'bento-doc', suggestedName: 'Q3.bento.html' }).catch(() => {})
+ await new Promise((r) => setTimeout(r, 0))
+ ok(nativeCalls.length === 0,
+ 'and an already-shipped document with only window.bento.updates.version still saves in place')
+}
+{
+ const { win, nativeCalls } = load({})
+ ;(win as any).__bentoRuntime = '1.0.14' // announced, but too old to trust the id
+ win.showSaveFilePicker({ id: 'bento-doc', suggestedName: 'Q3.bento.html' }).catch(() => {})
+ await new Promise((r) => setTimeout(r, 0))
+ ok(nativeCalls.length === 1,
+ 'the announcement is still gated on 1.0.15 — a pre-#213 runtime cannot be trusted to mean bento-doc')
+}
+
// ---- the version gate: a deck older than #213 sends bento-doc for EVERYTHING
for (const [version, trusted] of [
[undefined, false],
diff --git a/scripts/test-webext-i18n.ts b/scripts/test-webext-i18n.ts
new file mode 100644
index 00000000..e2f2c813
--- /dev/null
+++ b/scripts/test-webext-i18n.ts
@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+// tray/webext localisation rig.
+//
+// node scripts/test-webext-i18n.ts
+//
+// WHAT THIS PROVES. Every failure mode of a message catalogue is silent.
+//
+// · A key used in code but absent from English renders as the key name —
+// `helpAboutTitle` sitting where a heading should be.
+// · A key in a catalogue that no longer exists in code is dead weight nobody
+// will ever notice, and translators keep paying to maintain it.
+// · A locale missing a key falls back to English, so a German user gets a
+// German page with English sentences in it and nothing reports a fault.
+// · A `$1` that survives translation but loses its substitution shows the
+// user a literal dollar-one.
+//
+// None of these break anything. All of them are visible only to someone who
+// reads that language, which is precisely the person we do not have.
+
+import { readdirSync, readFileSync, existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { join, dirname } from 'node:path'
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..')
+const SRC = join(root, 'tray/webext')
+
+let failures = 0
+let checks = 0
+function ok(cond: boolean, msg: string) {
+ checks++
+ if (!cond) { failures++; console.log(` FAIL ${msg}`) }
+ else console.log(` ok ${msg}`)
+}
+
+const read = (p: string) => readFileSync(join(SRC, p), 'utf8')
+const cat = (loc: string) => JSON.parse(read(`_locales/${loc}/messages.json`)) as
+ Record<string, { message: string; description?: string }>
+
+const locales = readdirSync(join(SRC, '_locales')).sort()
+const en = cat('en')
+const enKeys = new Set(Object.keys(en))
+
+// ---- 1. what the code actually asks for -------------------------------------
+const sources = readdirSync(join(SRC, 'src')).filter((f) => /\.(js|html)$/.test(f))
+const used = new Set<string>()
+// i18n.js is skipped rather than comment-stripped. It documents the attributes
+// with EXAMPLE keys (`data-i18n="helpTitle"`) that no page ever renders, and it
+// renders nothing itself — so excluding the file is exact, where stripping
+// comments was not: a `*/` inside a regex or string swallowed real code after
+// it and reported live keys as dead.
+for (const f of sources) {
+ if (f === 'i18n.js') continue
+ const text = read(`src/${f}`).replace(/<!--[\s\S]*?-->/g, '')
+ for (const m of text.matchAll(/\bt\(\s*'([A-Za-z0-9_]+)'/g)) used.add(m[1])
+ for (const m of text.matchAll(/data-i18n(?:-html|-placeholder|-title)?="([A-Za-z0-9_]+)"/g)) used.add(m[1])
+}
+// Keys reached through a variable rather than a literal. Listed explicitly
+// because a rig that cannot see them would call them dead and delete them.
+for (const dynamic of ['agoHour', 'agoHours', 'agoDay', 'agoDays',
+ 'statusOneFolder', 'statusFolders', 'foundFolder', 'foundFolders']) used.add(dynamic)
+
+ok(used.size > 100, `the code references ${used.size} message keys`)
+
+const missing = [...used].filter((k) => !enKeys.has(k))
+ok(missing.length === 0,
+ `every key the code uses exists in English${missing.length ? `: missing ${missing.join(', ')}` : ''}`)
+
+const manifestMsgs = [...read('manifest.json').matchAll(/__MSG_([A-Za-z0-9_]+)__/g)].map((m) => m[1])
+const dead = [...enKeys].filter((k) => !used.has(k) && !manifestMsgs.includes(k))
+ok(dead.length === 0,
+ `no dead keys in English${dead.length ? `: ${dead.join(', ')}` : ''}`)
+
+// ---- 2. every locale is complete --------------------------------------------
+// Chrome falls back per key, so an incomplete catalogue is not broken — it is a
+// page in two languages, which is worse than either and reports nothing.
+for (const loc of locales) {
+ if (loc === 'en') continue
+ const c = cat(loc)
+ // `appName` is a product name and deliberately declared only in English.
+ const want = [...enKeys].filter((k) => k !== 'appName')
+ const gaps = want.filter((k) => !c[k])
+ ok(gaps.length === 0,
+ `${loc} is complete${gaps.length ? ` — ${gaps.length} missing: ${gaps.slice(0, 5).join(', ')}${gaps.length > 5 ? '…' : ''}` : ''}`)
+ const orphans = Object.keys(c).filter((k) => !enKeys.has(k))
+ ok(orphans.length === 0,
+ `${loc} carries no keys English lacks${orphans.length ? `: ${orphans.join(', ')}` : ''}`)
+}
+
+// ---- 3. substitutions survive translation -----------------------------------
+// `$1` is not a word. A translator who drops it leaves a sentence with a hole,
+// and one who adds a `$2` that the call site never passes shows a literal.
+for (const loc of locales) {
+ const c = cat(loc)
+ const wrong: string[] = []
+ for (const [k, v] of Object.entries(c)) {
+ if (!en[k]) continue
+ const want = new Set([...en[k].message.matchAll(/\$(\d)/g)].map((m) => m[1]))
+ const got = new Set([...v.message.matchAll(/\$(\d)/g)].map((m) => m[1]))
+ if (want.size !== got.size || [...want].some((n) => !got.has(n))) wrong.push(k)
+ }
+ ok(wrong.length === 0,
+ `${loc} keeps every substitution${wrong.length ? `: ${wrong.join(', ')}` : ''}`)
+}
+
+// ---- 4. the strings that must not be guessed at -----------------------------
+// A third of the catalogue explains a browser permission, where a mistranslation
+// costs somebody their folder grants rather than merely reading oddly. The
+// REVIEW note is how a translator knows which ones those are; losing it loses
+// the only signal they get.
+const flagged = Object.entries(en).filter(([, v]) => /REVIEW/.test(v.description ?? ''))
+ok(flagged.length > 20, `${flagged.length} English keys carry a REVIEW note for translators`)
+
+// And the one design decision that makes the rest safe: the prime block points
+// at Chrome's dialog by POSITION, never by reproducing its button labels, which
+// cannot be verified per language.
+for (const gone of ['primeAllowOnce', 'primeAllowAlways', 'primeDeny']) {
+ ok(!enKeys.has(gone),
+ `${gone} is gone — Chrome's own button wording is never reproduced`)
+}
+
+// ---- 5. the direction the layout is drawn in --------------------------------
+// Four of the shipped locales are right-to-left. Setting `dir` is half of it;
+// the CSS must also stop naming sides, or Arabic renders in a left-to-right
+// skeleton with the text mirrored inside it.
+const i18nSrc = read('src/i18n.js')
+ok(/applyDirection/.test(i18nSrc) && /getUILanguage/.test(i18nSrc),
+ 'the direction follows the browser language the catalogue was resolved from')
+for (const f of ['src/ui.css', 'src/home.html', 'src/panel.html']) {
+ const css = read(f)
+ const physical = [...css.matchAll(/^\s*[^/*\n]*?(text-align:\s*(left|right)|padding-left|padding-right|margin-left:\s*auto|border-right:|(?<![-\w])left:\s*\d)/gm)]
+ ok(physical.length === 0,
+ `${f} names no sides${physical.length ? ` (${physical.length} physical properties)` : ''}`)
+}
+if (existsSync(join(SRC, '_locales/ar'))) {
+ ok(/'ar'/.test(i18nSrc), 'Arabic ships, and the RTL set knows about it')
+}
+
+console.log(`\n${checks - failures}/${checks} checks passed`)
+if (failures) process.exit(1)
diff --git a/scripts/test-webext-library.ts b/scripts/test-webext-library.ts
new file mode 100644
index 00000000..4fca0972
--- /dev/null
+++ b/scripts/test-webext-library.ts
@@ -0,0 +1,558 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+// tray/webext document-library rig.
+//
+// node scripts/test-webext-library.ts
+//
+// WHAT THIS PROVES. The popup is a document browser now, and everything it
+// shows is DERIVED from files on disk — the title out of the document block,
+// the thumbnail out of the preview block, the openable path out of a prefix
+// learned elsewhere. Each of those is a parse against a format that moves, and
+// each fails in the same quiet way: a row that says `Q3-board` instead of
+// "Q3 Board Review", or a blank square where a picture should be. Nothing
+// throws, so nothing reports it.
+//
+// The title parse has form here. An earlier metadata reader looked for the
+// CLOSING `</script>` of the document block and so found nothing in any
+// document carrying an image, because those blocks run to megabytes — every
+// real deck showed no title, and it was caught only by opening real files.
+// So this rig reads a REAL BUILT SHELL where one is available, not only
+// hand-written fixtures shaped to pass.
+
+import { existsSync, readFileSync } from 'node:fs'
+import { listDocuments, describe, newDocument, duplicate, rename, APPS } from '../tray/webext/src/library.js'
+
+let failures = 0
+let checks = 0
+function ok(cond: boolean, msg: string) {
+ checks++
+ if (!cond) { failures++; console.log(` FAIL ${msg}`) }
+ else console.log(` ok ${msg}`)
+}
+
+// ---- fake filesystem --------------------------------------------------------
+function fileHandle(name: string, text = '', modified = 1_700_000_000_000) {
+ return {
+ kind: 'file' as const,
+ name,
+ async getFile() {
+ return {
+ size: text.length,
+ lastModified: modified,
+ async text() { return text },
+ // Copying is done as BYTES, not text — a document is not necessarily
+ // valid UTF-8 all the way through and a round trip through a string
+ // could rewrite it. The mock has to offer the same surface.
+ async arrayBuffer() { return new TextEncoder().encode(text).buffer },
+ slice(a: number, b: number) {
+ const part = text.slice(a, b)
+ return { async text() { return part } }
+ },
+ }
+ },
+ async createWritable() {
+ return {
+ async write(chunk: any) {
+ written.set(name, typeof chunk === 'string'
+ ? chunk
+ : new TextDecoder().decode(chunk))
+ },
+ async close() {},
+ }
+ },
+ }
+}
+const written = new Map<string, string>()
+
+function dirHandle(name: string, tree: Record<string, any>, perm = 'granted') {
+ return {
+ kind: 'directory' as const,
+ name,
+ async queryPermission() { return perm },
+ async getFileHandle(n: string, opts?: { create?: boolean }) {
+ const v = tree[n]
+ if (v && v.kind === 'file') return v
+ if (!opts?.create) throw Object.assign(new Error(n), { name: 'NotFoundError' })
+ const h = fileHandle(n)
+ tree[n] = h
+ return h
+ },
+ async *entries() {
+ for (const [k, v] of Object.entries(tree)) {
+ yield [k, v.kind ? v : dirHandle(k, v, perm)] as const
+ }
+ },
+ }
+}
+
+const noCache = { get: async () => null, put: async () => {} }
+
+/** A cache that behaves, so `sniff` actually runs. Without one it throws into a
+ * `catch { continue }` and the rig quietly proves nothing. */
+const memCache = () => {
+ const m = new Map<string, any>()
+ return {
+ store: m,
+ get: async (k: string) => m.get(k) ?? null,
+ put: async (k: string, v: any) => { m.set(k, v) },
+ }
+}
+
+// ---- 1. what counts as a document ------------------------------------------
+{
+ const tree = {
+ 'Q3.bento.html': fileHandle('Q3.bento.html'),
+ 'notes.txt': fileHandle('notes.txt'),
+ 'page.html': fileHandle('page.html'), // html, but not ours
+ '.hidden': { 'Secret.bento.html': fileHandle('Secret.bento.html') },
+ Clients: { 'Plan.bento.html': fileHandle('Plan.bento.html') },
+ }
+ const docs = await listDocuments({
+ getGrants: async () => [dirHandle('Decks', tree)],
+ prefixes: async () => ({}),
+ ...memCache(),
+ })
+ const names = docs.map((d: any) => d.name).sort()
+ ok(names.length === 2 && names[0] === 'Plan.bento.html' && names[1] === 'Q3.bento.html',
+ `only .bento.html documents are listed, at any depth (${names.join(', ')})`)
+ ok(!docs.some((d: any) => d.name === 'Secret.bento.html'),
+ 'a dot-directory is not walked — those are caches and version control, not documents')
+ ok(docs.every((d: any) => d.path === null),
+ 'without a learned prefix a document has no path, so the row can say it is not openable')
+ ok(docs.find((d: any) => d.name === 'Plan.bento.html')?.rel.join('/') === 'Clients/Plan.bento.html',
+ 'a nested document keeps its route, which is what the path is built from')
+}
+{
+ const tree = { Clients: { 'Plan.bento.html': fileHandle('Plan.bento.html') } }
+ const docs = await listDocuments({
+ getGrants: async () => [dirHandle('Decks', tree)],
+ prefixes: async () => ({ Decks: '/Users/x/Decks' }),
+ ...memCache(),
+ })
+ ok(docs[0].path === '/Users/x/Decks/Clients/Plan.bento.html',
+ 'with a learned prefix the absolute path is reassembled — this is what makes a row clickable')
+}
+{
+ // A lapsed folder cannot be read; the OTHER folders must still list.
+ const good = dirHandle('Good', { 'A.bento.html': fileHandle('A.bento.html') })
+ const bad = dirHandle('Bad', { 'B.bento.html': fileHandle('B.bento.html') }, 'prompt')
+ const docs = await listDocuments({ getGrants: async () => [bad, good], prefixes: async () => ({}), ...memCache() })
+ ok(docs.length === 1 && docs[0].name === 'A.bento.html',
+ 'a lapsed folder is skipped rather than throwing, so one bad grant cannot empty the list')
+}
+
+// ---- 1b. a document is one because of what is INSIDE it ---------------------
+// The name is a convention, and people break conventions: renamed to email it,
+// saved with a "(1)", downloaded as .html. Those are still documents this can
+// open, and a regular expression on the name cannot see them.
+const BENTO = '<script id="bento-doc" type="application/json">{"title":"Renamed"}</script>'
+{
+ const cache = memCache()
+ const tree = {
+ 'Q3.bento.html': fileHandle('Q3.bento.html', BENTO),
+ 'deck.html': fileHandle('deck.html', BENTO), // ours, renamed
+ 'index.html': fileHandle('index.html', '<html>a web page</html>'),
+ 'notes.txt': fileHandle('notes.txt', BENTO), // ours, but not html
+ 'huge.html': fileHandle('huge.html', `${'x'.repeat(200_000)}${BENTO}`), // marker past the sniff
+ }
+ const docs = await listDocuments({
+ getGrants: async () => [dirHandle('Decks', tree)], prefixes: async () => ({}), ...cache,
+ })
+ const names = docs.map((d: any) => d.name).sort()
+ ok(names.includes('deck.html'),
+ `a Bento document under another name is found (${names.join(', ')})`)
+ ok(!names.includes('index.html'),
+ 'an ordinary web page in the same folder is not — the marker decides, not the extension')
+ ok(!names.includes('notes.txt'),
+ 'and a non-html file is never opened at all, whatever is in it')
+ ok(!names.includes('huge.html'),
+ 'a marker beyond the sniff window is not found — bounded, and the bound is honest')
+ ok(docs.find((d: any) => d.name === 'deck.html')?.base === 'deck',
+ 'a renamed document loses only its extension when named')
+ ok(docs.find((d: any) => d.name === 'Q3.bento.html')?.named === true
+ && docs.find((d: any) => d.name === 'deck.html')?.named === false,
+ 'and the two are distinguishable, because only one of them saves in place')
+}
+{
+ // The sniff must be cached, or every popup re-reads every stray .html.
+ const cache = memCache()
+ // Count CONTENT reads, not getFile(). The cache key is built from size and
+ // mtime, so a hit still asks for the File — that is metadata, and cheap. What
+ // must not happen twice is opening the bytes.
+ let bytesRead = 0
+ const counting = fileHandle('deck.html', BENTO)
+ const origGet = counting.getFile.bind(counting)
+ ;(counting as any).getFile = async () => {
+ const f: any = await origGet()
+ const origSlice = f.slice.bind(f)
+ f.slice = (a: number, b: number) => { bytesRead++; return origSlice(a, b) }
+ return f
+ }
+ const tree = { 'deck.html': counting }
+ const args = { getGrants: async () => [dirHandle('Decks', tree)], prefixes: async () => ({}), ...cache }
+ await listDocuments(args)
+ const first = bytesRead
+ await listDocuments(args)
+ ok(first === 1 && bytesRead === 1,
+ `a second listing opens no bytes (${first} then ${bytesRead} content reads)`)
+ ok([...cache.store.keys()].some((k) => k.startsWith('sniff:')),
+ 'the verdict is cached under its own key, alongside titles and previews')
+}
+{
+ // A folder of a thousand unrelated pages must not cost a thousand reads
+ // FOREVER. The budget is per listing; named documents never spend from it.
+ const cache = memCache()
+ let reads = 0
+ const tree: Record<string, any> = {}
+ for (let i = 0; i < 500; i++) {
+ const h = fileHandle(`page${i}.html`, '<html>not ours</html>')
+ const orig = h.getFile.bind(h)
+ ;(h as any).getFile = async () => { reads++; return orig() }
+ tree[`page${i}.html`] = h
+ }
+ tree['Real.bento.html'] = fileHandle('Real.bento.html', BENTO)
+ const docs = await listDocuments({
+ getGrants: async () => [dirHandle('Decks', tree)], prefixes: async () => ({}), ...cache,
+ })
+ ok(reads <= 400, `sniffing is capped per listing (${reads} reads for 500 candidates)`)
+ ok(docs.some((d: any) => d.name === 'Real.bento.html'),
+ 'and a properly named document is listed regardless — it never spends from the budget')
+}
+
+// ---- 2. title and preview, against a REAL shell -----------------------------
+// The parse that has failed before. Fixtures shaped by hand would have passed
+// then too; only a real file caught it.
+const REAL = 'slides/dist-single/Bento_Slides.bento.html'
+if (existsSync(REAL)) {
+ const html = readFileSync(REAL, 'utf8')
+ const doc = { base: 'Bento_Slides', folder: 'Decks', rel: ['Bento_Slides.bento.html'],
+ handle: fileHandle('Bento_Slides.bento.html', html) }
+ const meta = await describe(doc as any, noCache)
+ // A PRISTINE shell ships with an EMPTY block — `id="bento-doc"></script>` —
+ // because the starter document is built at runtime and only written into the
+ // file on the first save. So it legitimately has no title, and the filename
+ // fallback is the right answer rather than a parse failure. This is also what
+ // `+ New document` produces, so its rows read "Untitled" until first saved.
+ ok(meta.title === 'Bento_Slides',
+ 'a pristine shell has no document in it yet, so the file name is shown')
+ ok(meta.encrypted === false, 'and it is not mistaken for an encrypted document')
+
+ const docBlock = html.indexOf('id="bento-doc"')
+ ok(docBlock > 0 && docBlock < 300 * 1024,
+ `the document block starts inside the head that is read (${Math.round(docBlock / 1024)}KB)`)
+
+ // And now the case that matters: the same real shell with a document spliced
+ // in, at the real offset, in the real byte layout. This is what every SAVED
+ // document looks like, and it is where the previous metadata reader failed —
+ // it hunted for the block's closing tag, which sits megabytes away in any
+ // document carrying an image.
+ const saved = html.replace('id="bento-doc"></script>',
+ 'id="bento-doc">{"format":"bento/slides","title":"Q3 Board Review","slides":[]}</script>')
+ ok(saved !== html, 'the fixture actually spliced (the empty-block shape has not changed)')
+ const savedMeta = await describe({ ...doc, handle: fileHandle('Q3.bento.html', saved) } as any, noCache)
+ ok(savedMeta.title === 'Q3 Board Review',
+ `a saved document yields its title from inside a real shell (${JSON.stringify(savedMeta.title)})`)
+
+ // Same shell, but with a megabyte of document after the title — the exact
+ // shape that broke the old reader. The title must still be found, because it
+ // is matched directly rather than by finding the end of the block.
+ const big = html.replace('id="bento-doc"></script>',
+ `id="bento-doc">{"title":"Big Deck","blob":"${'x'.repeat(1_200_000)}"}</script>`)
+ const bigMeta = await describe({ ...doc, handle: fileHandle('Big.bento.html', big) } as any, noCache)
+ ok(bigMeta.title === 'Big Deck',
+ 'and still yields it when the document block runs past the head that is read')
+} else {
+ console.log(' .. skipped real-shell checks (no dist-single build present)')
+}
+
+// ---- 3. title and preview, synthetic edge cases -----------------------------
+{
+ const withPreview =
+ '<html><script id="bento-doc" type="application/json">{"title":"Q3 Board Review","slides":[]}</script>'
+ + '<div data-bento-preview="1"><b>page one</b></div>'
+ + '<script data-bento-preview="1">/* remover */</script></html>'
+ const meta = await describe({ base: 'Q3', folder: 'D', rel: ['Q3.bento.html'],
+ handle: fileHandle('Q3.bento.html', withPreview) } as any, noCache)
+ ok(meta.title === 'Q3 Board Review', 'the title is read out of the document block')
+ ok(meta.preview === '<div data-bento-preview="1"><b>page one</b></div>',
+ 'the preview block is extracted whole, and stops before the script that removes it')
+ ok(!meta.preview!.includes('<script'),
+ 'no script comes with it — the thumbnail renders inert in a sandboxed frame')
+}
+{
+ // The remover script MUST NOT be included: it deletes the very element we are
+ // about to render, so a sloppy boundary produces a blank thumbnail that looks
+ // like a rendering bug rather than a parsing one.
+ const meta = await describe({ base: 'X', folder: 'D', rel: ['X.bento.html'],
+ handle: fileHandle('X.bento.html', '<div data-bento-preview="1">hi</div>') } as any, noCache)
+ ok(meta.preview === null,
+ 'a preview with no closing marker is refused rather than run past the end of the file')
+}
+{
+ const enc = '<script id="bento-doc" type="application/json">{"format":"bento/enc","v":1}</script>'
+ const meta = await describe({ base: 'Locked', folder: 'D', rel: ['Locked.bento.html'],
+ handle: fileHandle('Locked.bento.html', enc) } as any, noCache)
+ ok(meta.encrypted === true, 'an encrypted document is recognised')
+ ok(meta.preview === null,
+ 'and gets NO preview — a plaintext title page beside the ciphertext is the leak the password prevents')
+ ok(meta.title === 'Locked', 'falling back to the file name, since there is no readable title')
+}
+{
+ const meta = await describe({ base: 'Plain', folder: 'D', rel: ['Plain.bento.html'],
+ handle: fileHandle('Plain.bento.html', '<html>nothing here</html>') } as any, noCache)
+ ok(meta.title === 'Plain', 'a document with no title falls back to its file name rather than blank')
+}
+{
+ // The cache is keyed on size and mtime, so an edited document must re-read.
+ const calls: string[] = []
+ const cache = new Map<string, any>()
+ const deps = {
+ get: async (k: string) => { calls.push(`get ${k}`); return cache.get(k) ?? null },
+ put: async (k: string, v: any) => { cache.set(k, v) },
+ }
+ const body = '<script id="bento-doc">{"title":"One"}</script>'
+ const d1 = { base: 'C', folder: 'D', rel: ['C.bento.html'], handle: fileHandle('C.bento.html', body, 1) }
+ await describe(d1 as any, deps)
+ const again = await describe(d1 as any, deps)
+ ok(again.title === 'One' && cache.size === 1, 'an unchanged document is served from cache')
+ const d2 = { ...d1, handle: fileHandle('C.bento.html', '<script id="bento-doc">{"title":"Two"}</script>', 2) }
+ const edited = await describe(d2 as any, deps)
+ ok(edited.title === 'Two' && cache.size === 2,
+ 'an edited document re-reads — the key carries size and mtime, so nothing needs invalidating by hand')
+}
+
+// ---- 4. new document --------------------------------------------------------
+const fakeNet = (version = '1.0.17', html = '<html>shell</html>') => async (url: string) => ({
+ ok: true,
+ async json() { return { version, url: 'https://bento.page/releases/slides/Bento_Slides.bento.html' } },
+ async text() { return html },
+ url,
+})
+{
+ written.clear()
+ const tree: Record<string, any> = {}
+ const dir = dirHandle('Decks', tree)
+ const made = await newDocument(dir as any, 'Untitled', { fetch: fakeNet() })
+ ok(made.name === 'Untitled.bento.html', 'the first new document is Untitled.bento.html')
+ ok(written.get('Untitled.bento.html') === '<html>shell</html>',
+ 'and carries the downloaded release, so it is the same version everyone else has')
+}
+{
+ written.clear()
+ const tree: Record<string, any> = { 'Untitled.bento.html': fileHandle('Untitled.bento.html') }
+ const dir = dirHandle('Decks', tree)
+ const made = await newDocument(dir as any, 'Untitled', { fetch: fakeNet() })
+ // UIKit's own de-duplicator produces "Untitled.bento 2.html" here, because it
+ // reads `.bento.html` as the name "Untitled.bento" plus extension "html" and
+ // counts before the LAST extension only. tray/ios had to write its own for
+ // exactly this; so does this.
+ ok(made.name === 'Untitled 2.bento.html',
+ `a second document counts on the base name, not inside the extension (${made.name})`)
+ ok(!/\.bento \d/.test(made.name), 'never "Untitled.bento 2.html" — the double extension trap')
+}
+{
+ const dir = dirHandle('Decks', {})
+ let threw = ''
+ await newDocument(dir as any, 'X', { fetch: async () => ({ ok: false, status: 503 }) })
+ .catch((e: any) => { threw = e.message })
+ ok(/release server/.test(threw), `an unreachable release server is reported, not silent (${threw})`)
+}
+{
+ const dir = dirHandle('Decks', {})
+ let threw = ''
+ await newDocument(dir as any, 'X', {
+ fetch: async () => ({ ok: true, async json() { return {} } }),
+ }).catch((e: any) => { threw = e.message })
+ ok(/did not offer a build/.test(threw), 'a manifest with no build is reported rather than written as empty')
+}
+
+// ---- 5. duplicate and rename ------------------------------------------------
+// The only two operations that CHANGE somebody's documents. Deleting is
+// deliberately absent — it needs an undo, a trash and a confirmation people
+// actually read, and Finder has all three — so these two carry the whole risk.
+{
+ written.clear()
+ const original = fileHandle('Q3.bento.html', '<html>original</html>')
+ const tree: Record<string, any> = { 'Q3.bento.html': original }
+ const dir = dirHandle('Decks', tree)
+ const doc = { name: 'Q3.bento.html', base: 'Q3', folder: 'Decks', rel: ['Q3.bento.html'],
+ handle: original, parent: dir }
+ const made = await duplicate(doc as any)
+ ok(made.name === 'Q3 copy.bento.html', `a duplicate is named for the original (${made.name})`)
+ ok(written.get('Q3 copy.bento.html') === '<html>original</html>',
+ 'and is byte-for-byte — a Bento document carries its own runtime, keys and identity, '
+ + 'and a file manager has no standing to re-derive any of that')
+ ok(tree['Q3.bento.html'] === original, 'the original is untouched')
+
+ const second = await duplicate(doc as any)
+ ok(second.name === 'Q3 copy 2.bento.html', `duplicating twice counts on the base (${second.name})`)
+}
+{
+ written.clear()
+ const removed: string[] = []
+ const original = fileHandle('Old.bento.html', '<html>content</html>')
+ const tree: Record<string, any> = { 'Old.bento.html': original }
+ const dir: any = dirHandle('Decks', tree)
+ dir.removeEntry = async (n: string) => { removed.push(n); delete tree[n] }
+ const doc = { name: 'Old.bento.html', base: 'Old', folder: 'Decks', rel: ['Old.bento.html'],
+ handle: original, parent: dir }
+
+ const made = await rename(doc as any, 'New Name')
+ ok(made.name === 'New Name.bento.html', `renaming writes the new name (${made.name})`)
+ ok(written.get('New Name.bento.html') === '<html>content</html>', 'with the original content')
+ ok(removed.length === 1 && removed[0] === 'Old.bento.html', 'and removes the old file after')
+}
+{
+ // WRITE THEN REMOVE, never the reverse. If the write fails the original must
+ // survive; removing first would put the only copy of somebody's document in
+ // a variable. Proven by making the write fail and checking nothing was lost.
+ const removed: string[] = []
+ const original = fileHandle('Keep.bento.html', '<html>precious</html>')
+ const tree: Record<string, any> = { 'Keep.bento.html': original }
+ const dir: any = dirHandle('Decks', tree)
+ dir.removeEntry = async (n: string) => { removed.push(n) }
+ const realGet = dir.getFileHandle.bind(dir)
+ dir.getFileHandle = async (n: string, o?: any) => {
+ if (o?.create) throw new Error('disk full')
+ return realGet(n, o)
+ }
+ const doc = { name: 'Keep.bento.html', base: 'Keep', folder: 'Decks', rel: ['Keep.bento.html'],
+ handle: original, parent: dir }
+ let threw = ''
+ await rename(doc as any, 'Whatever').catch((e: any) => { threw = e.message })
+ ok(threw === 'disk full', 'a failed rename reports the failure')
+ ok(removed.length === 0, 'and removes nothing — the original survives a write that did not happen')
+}
+{
+ const dir: any = dirHandle('Decks', {})
+ const doc = { name: 'A.bento.html', base: 'A', folder: 'Decks', rel: ['A.bento.html'],
+ handle: fileHandle('A.bento.html', 'x'), parent: dir }
+ let threw = ''
+ await rename(doc as any, ' ').catch((e: any) => { threw = e.message })
+ ok(/needs a name/.test(threw), 'an empty name is refused rather than creating ".bento.html"')
+
+ dir.removeEntry = async () => {}
+ const same = await rename(doc as any, 'A')
+ ok(same.name === 'A.bento.html', 'renaming to the same name is a no-op, not a duplicate')
+}
+{
+ // A name is about to become a filename, and it comes from a prompt box.
+ const removed: string[] = []
+ const tree: Record<string, any> = { 'A.bento.html': fileHandle('A.bento.html', 'x') }
+ const dir: any = dirHandle('Decks', tree)
+ dir.removeEntry = async (n: string) => { removed.push(n) }
+ const doc = { name: 'A.bento.html', base: 'A', folder: 'Decks', rel: ['A.bento.html'],
+ handle: tree['A.bento.html'], parent: dir }
+ const made = await rename(doc as any, '../../etc/passwd')
+ ok(!made.name.includes('/') && !made.name.includes('..') && !made.name.startsWith('.'),
+ `separators are stripped, so a name cannot escape its folder (${made.name})`)
+ ok(made.name === 'etcpasswd.bento.html',
+ `and what is left is an ordinary visible file name (${made.name})`)
+ const made2 = await rename({ ...doc, base: made.base, name: made.name,
+ handle: tree[made.name] } as any, 'Report.bento.html')
+ ok(made2.name === 'Report.bento.html',
+ `typing the extension does not double it (${made2.name})`)
+}
+
+// ---- 6. the Bento family ----------------------------------------------------
+// Listing, opening, thumbnails and in-place saving are all app-blind: the whole
+// family writes .bento.html and carries its own runtime. Creating is the one
+// operation that must ask which app, because there is no document yet to ask.
+{
+ ok(APPS.length >= 3 && APPS.every((a) => a.id && a.name && a.manifest),
+ `every app has an id, a name and a release channel (${APPS.map((a) => a.id).join(', ')})`)
+ ok(new Set(APPS.map((a) => a.manifest)).size === APPS.length,
+ 'and its own manifest — a shared one would make every new document the same app')
+ ok(APPS.every((a) => a.manifest.startsWith('https://')),
+ 'fetched over https: this downloads code that becomes a file on disk')
+}
+{
+ written.clear()
+ const asked: string[] = []
+ const net = async (url: string) => {
+ asked.push(url)
+ return {
+ ok: true,
+ async json() { return { version: '1.0.0', url: 'https://bento.page/x.bento.html' } },
+ async text() { return '<html>spaces</html>' },
+ }
+ }
+ const dir = dirHandle('Decks', {})
+ const made = await newDocument(dir as any, 'Untitled', { fetch: net, app: 'spaces' })
+ ok(asked[0].includes('/spaces/'), `the chosen app's channel is used (${asked[0]})`)
+ ok(made.app === 'Spaces', `and the result says what was made (${made.app})`)
+}
+{
+ // An unknown app must not silently fetch nothing, nor pick at random.
+ const asked: string[] = []
+ const net = async (url: string) => {
+ asked.push(url)
+ return { ok: true, async json() { return { version: '1', url: 'https://x/y' } }, async text() { return 'x' } }
+ }
+ await newDocument(dirHandle('Decks', {}) as any, 'Untitled', { fetch: net, app: 'nonsense' })
+ ok(asked[0] === APPS[0].manifest,
+ 'an unknown app falls back to the first, rather than requesting an invented URL')
+}
+
+// ---- 7. searching what a document SAYS --------------------------------------
+// Search covered the title, the file name and the folder — which finds a
+// document you can already name. What people remember is a phrase on a slide,
+// and the bytes to answer that were already read for the thumbnail.
+{
+ const doc = '<script id="bento-doc" type="application/json">'
+ + '{"format":"bento/slides","title":"Q3","slides":[{"id":"s1",'
+ + '"elements":[{"type":"text","html":"<b>Revenue</b> grew 40% in Iberia"}],'
+ + '"notes":"remember to mention the Lisbon office"}]}</script>'
+ const meta = await describe({ base: 'Q3', folder: 'D', rel: ['Q3.bento.html'],
+ handle: fileHandle('Q3.bento.html', doc) } as any, noCache)
+ const text = (meta.text ?? '').toLowerCase()
+ ok(text.includes('revenue') && text.includes('iberia'),
+ 'prose from a slide is searchable')
+ ok(text.includes('lisbon'), 'and so are speaker notes — often the only place a name appears')
+ ok(!text.includes('bento-doc') && !/\bformat\b/.test(text),
+ 'JSON keys are not indexed — values only, or every document matches "format"')
+ ok(!text.includes('<b>'), 'markup is stripped, so a search for "b" does not match every bold word')
+}
+{
+ // An embedded image is bigger than every word in the document. If data URIs
+ // are not dropped first they dominate the budget and the work.
+ const big = '<script id="bento-doc">{"src":"data:image/png;base64,'
+ + 'A'.repeat(300_000) + '","html":"findable phrase"}</script>'
+ const meta = await describe({ base: 'Img', folder: 'D', rel: ['Img.bento.html'],
+ handle: fileHandle('Img.bento.html', big) } as any, noCache)
+ ok((meta.text ?? '').includes('findable phrase'),
+ 'text after a huge data URI is still found — the URI is dropped, not skipped past')
+ ok((meta.text ?? '').length < 1000, `and the URI itself is not indexed (${meta.text?.length} chars)`)
+}
+{
+ // Capped, or a folder of large documents becomes a search index.
+ const many = '<script id="bento-doc">{'
+ + Array.from({ length: 4000 }, (_, i) => `"k${i}":"word${i} some prose here"`).join(',')
+ + '}</script>'
+ const meta = await describe({ base: 'Big', folder: 'D', rel: ['Big.bento.html'],
+ handle: fileHandle('Big.bento.html', many) } as any, noCache)
+ ok((meta.text ?? '').length <= 40 * 1024,
+ `extraction is capped (${meta.text?.length} chars)`)
+}
+{
+ const enc = '<script id="bento-doc">{"format":"bento/enc","v":1,"ct":"AAAA"}</script>'
+ const meta = await describe({ base: 'Locked', folder: 'D', rel: ['L.bento.html'],
+ handle: fileHandle('L.bento.html', enc) } as any, noCache)
+ ok(meta.text === null,
+ 'an encrypted document is not indexed — the ciphertext is not text, and a '
+ + 'search index of a password-protected file is the leak the password prevents')
+}
+if (existsSync(REAL)) {
+ // The real thing: a built shell with a real document spliced in.
+ const html = readFileSync(REAL, 'utf8')
+ const saved = html.replace('id="bento-doc"></script>',
+ 'id="bento-doc">{"title":"Deck","slides":[{"notes":"the quarterly figures for Iberia"}]}</script>')
+ const meta = await describe({ base: 'Deck', folder: 'D', rel: ['Deck.bento.html'],
+ handle: fileHandle('Deck.bento.html', saved) } as any, noCache)
+ ok((meta.text ?? '').toLowerCase().includes('iberia'),
+ 'and it finds prose inside a real built shell, not only a fixture')
+}
+
+console.log(`\n${checks - failures}/${checks} checks passed`)
+if (failures) process.exit(1)
diff --git a/scripts/test-webext-route.ts b/scripts/test-webext-route.ts
new file mode 100644
index 00000000..fb2afb51
--- /dev/null
+++ b/scripts/test-webext-route.ts
@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+// tray/webext route rig.
+//
+// node scripts/test-webext-route.ts
+//
+// WHAT THIS PROVES. `prefixFor` turns "an absolute path" into "where this
+// granted folder lives", and that answer is then used to build the URLs the
+// tray opens. It is fed by browser HISTORY — paths the extension did not
+// choose, for files that may have moved, been deleted, or never been in a
+// granted folder at all.
+//
+// So the only property that matters is that it PROVES rather than guesses. A
+// path is accepted only when the route resolves inside the grant AND
+// `dir.resolve()` on what it lands on agrees with the path's own tail. The
+// failure mode of getting this wrong is not a broken link: it is a folder
+// recorded at the wrong location, and every document in it opening something
+// else.
+
+import { pathFromSender, locateIn, prefixFor } from '../tray/webext/src/route.js'
+
+let failures = 0
+let checks = 0
+function ok(cond: boolean, msg: string) {
+ checks++
+ if (!cond) { failures++; console.log(` FAIL ${msg}`) }
+ else console.log(` ok ${msg}`)
+}
+
+function fileHandle(name: string, rel: string[]) {
+ return { kind: 'file' as const, name, __rel: rel }
+}
+function dirHandle(name: string, tree: Record<string, any>, base: string[] = []) {
+ return {
+ kind: 'directory' as const,
+ name: base.at(-1) ?? name,
+ async resolve(child: any) {
+ const rel = child?.__rel
+ if (!rel) return null
+ return base.every((seg, i) => rel[i] === seg) ? rel.slice(base.length) : null
+ },
+ async getDirectoryHandle(n: string) {
+ const v = tree[n]
+ if (!v || v.kind) throw Object.assign(new Error(n), { name: 'NotFoundError' })
+ return dirHandle(name, v, [...base, n])
+ },
+ async getFileHandle(n: string) {
+ const v = tree[n]
+ if (v && v.kind === 'file') return v
+ throw Object.assign(new Error(n), { name: 'NotFoundError' })
+ },
+ }
+}
+
+// ---- the sender's path ------------------------------------------------------
+ok(pathFromSender({ url: 'file:///Users/x/Decks/Q3.bento.html' }) === '/Users/x/Decks/Q3.bento.html',
+ 'a file:// sender yields its path')
+ok(pathFromSender({ url: 'https://evil.example/x.bento.html' }) === null,
+ 'an http sender is refused — the bridge is for local documents')
+ok(pathFromSender({ url: 'file:///Users/x/My%20Decks/Q3.bento.html' }) === '/Users/x/My Decks/Q3.bento.html',
+ 'a percent-encoded path is decoded')
+
+// ---- placing a path ---------------------------------------------------------
+{
+ const dir = dirHandle('Decks', { 'Q3.bento.html': fileHandle('Q3.bento.html', ['Q3.bento.html']) })
+ const p = await prefixFor(dir, '/Users/andy/Work/Decks/Q3.bento.html')
+ ok(p === '/Users/andy/Work/Decks', `a document at the grant root places the folder (${p})`)
+}
+{
+ const dir = dirHandle('Decks', {
+ Clients: { 'Q3.bento.html': fileHandle('Q3.bento.html', ['Clients', 'Q3.bento.html']) },
+ })
+ const p = await prefixFor(dir, '/Users/andy/Decks/Clients/Q3.bento.html')
+ ok(p === '/Users/andy/Decks', `a nested document places the folder, not its subfolder (${p})`)
+}
+{
+ // The grant's name repeating in the path. Both split points are tried, and
+ // only the one that actually resolves is taken.
+ const dir = dirHandle('Decks', {
+ Decks: { 'Q3.bento.html': fileHandle('Q3.bento.html', ['Decks', 'Q3.bento.html']) },
+ })
+ const p = await prefixFor(dir, '/Users/andy/Decks/Decks/Q3.bento.html')
+ ok(p === '/Users/andy/Decks', `a repeated folder name resolves to the route that exists (${p})`)
+}
+
+// ---- what must be REFUSED ---------------------------------------------------
+// History is full of paths that are nothing to do with a grant. Every one of
+// these would, if accepted, record a folder at the wrong place — and then every
+// document in it opens the wrong file, silently.
+{
+ const dir = dirHandle('Decks', { 'Q3.bento.html': fileHandle('Q3.bento.html', ['Q3.bento.html']) })
+ ok(await prefixFor(dir, '/Users/andy/Elsewhere/Q3.bento.html') === null,
+ 'a path whose folder name does not appear is refused')
+ ok(await prefixFor(dir, '/Users/andy/Decks/Missing.bento.html') === null,
+ 'a document that is not in the grant is refused, even under the right folder name')
+ ok(await prefixFor(dir, '/Users/andy/Decks/Sub/Q3.bento.html') === null,
+ 'a route through a directory that does not exist is refused')
+ ok(await prefixFor(dir, '/Q3.bento.html') === null,
+ 'a path with no folder segment at all is refused')
+}
+{
+ // The case that has destroyed a document before: same NAME, different FILE.
+ // `dir.resolve` reports where the candidate really sits, and it must agree
+ // with the path's own tail.
+ const dir = dirHandle('Decks', {
+ Clients: { 'Q3.bento.html': fileHandle('Q3.bento.html', ['Clients', 'Q3.bento.html']) },
+ })
+ // A history entry for a DIFFERENT Q3 at the grant root — the grant has no such
+ // file, only Clients/Q3, so nothing may be learned from it.
+ ok(await prefixFor(dir, '/Users/andy/Decks/Q3.bento.html') === null,
+ 'a same-named file at a different depth teaches nothing — resolve() must agree with the tail')
+}
+{
+ // A handle the directory refuses to resolve (outside it) must not be trusted
+ // even though the route reached something.
+ const orphan: any = fileHandle('Q3.bento.html', ['Q3.bento.html'])
+ orphan.__rel = null
+ const dir = dirHandle('Decks', { 'Q3.bento.html': orphan })
+ ok(await prefixFor(dir, '/Users/andy/Decks/Q3.bento.html') === null,
+ 'a candidate the grant will not resolve is refused')
+}
+
+// ---- locateIn does not enumerate -------------------------------------------
+// The whole reason the route exists: a grant may be a home directory, and
+// placing a path must not walk it.
+{
+ const tree: Record<string, any> = { 'Q3.bento.html': fileHandle('Q3.bento.html', ['Q3.bento.html']) }
+ for (let i = 0; i < 500; i++) tree[`junk${i}`] = { x: fileHandle('x', ['x']) }
+ const dir: any = dirHandle('home', tree)
+ let enumerated = 0
+ dir.entries = async function* () { enumerated++ }
+ const hits = await locateIn(dir, '/Users/andy/home/Q3.bento.html')
+ ok(hits.length === 1, 'the route finds the file inside a 500-entry grant')
+ ok(enumerated === 0, `and enumerates nothing to do it (${enumerated} scans)`)
+}
+
+console.log(`\n${checks - failures}/${checks} checks passed`)
+if (failures) process.exit(1)
diff --git a/scripts/test-webext-update.ts b/scripts/test-webext-update.ts
new file mode 100644
index 00000000..384a986e
--- /dev/null
+++ b/scripts/test-webext-update.ts
@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+// tray/webext update-notice rig.
+//
+// node scripts/test-webext-update.ts
+//
+// WHAT THIS PROVES. Store installs update themselves; an extension loaded
+// unpacked NEVER does — Chrome ignores `update_url` for a development install.
+// So the GitHub route needs telling, and the telling has to be exactly right in
+// both directions:
+//
+// · a STORE user must never see it. They cannot act on it, the browser has
+// already handled it, and a notice about a version they already have is the
+// kind of thing that gets an extension uninstalled.
+// · an UNPACKED user must see it, because nothing else will ever say so.
+//
+// Everything here is a silent failure by nature: a comparison that goes the
+// wrong way, a fetch that throws, an install type that cannot be read. None of
+// it breaks anything visible, which is exactly why it needs a rig.
+
+import { compareVersions, isSelfManaged, checkForUpdate, autoCheckEnabled } from '../tray/webext/src/update.js'
+
+let failures = 0
+let checks = 0
+function ok(cond: boolean, msg: string) {
+ checks++
+ if (!cond) { failures++; console.log(` FAIL ${msg}`) }
+ else console.log(` ok ${msg}`)
+}
+
+// ---- version comparison -----------------------------------------------------
+{
+ ok(compareVersions('1.0.1', '1.0.0') > 0, '1.0.1 is newer than 1.0.0')
+ ok(compareVersions('1.0.0', '1.0.1') < 0, 'and the reverse holds')
+ ok(compareVersions('1.0.0', '1.0.0') === 0, 'equal versions compare equal')
+ // The one that bites: string comparison puts "1.0.10" before "1.0.9".
+ ok(compareVersions('1.0.10', '1.0.9') > 0,
+ '1.0.10 is newer than 1.0.9 — compared as numbers, not as text')
+ ok(compareVersions('1.1', '1.0.9') > 0, 'a shorter version still compares by significance')
+ ok(compareVersions('2.0', '1.9.9') > 0, 'a major bump wins over everything below it')
+}
+
+// ---- who gets asked ---------------------------------------------------------
+{
+ ok(await isSelfManaged({ getSelf: async () => ({ installType: 'development' }) }),
+ 'an unpacked install is one that must be told')
+ ok(!(await isSelfManaged({ getSelf: async () => ({ installType: 'normal' }) })),
+ 'a store install is NOT — the browser already updates it')
+ for (const t of ['sideload', 'admin', 'other']) {
+ ok(await isSelfManaged({ getSelf: async () => ({ installType: t }) }),
+ `${t} is told too — it also arrives outside the store's update mechanism`)
+ }
+ ok(!(await isSelfManaged({ getSelf: async () => { throw new Error('no API') } })),
+ 'and an install type that cannot be read stays silent rather than guessing')
+}
+
+// ---- the check --------------------------------------------------------------
+const dev = async () => ({ installType: 'development' })
+const store = async () => ({ installType: 'normal' })
+const serving = (body: any, okFlag = true) => async () => ({
+ ok: okFlag, async json() { return body },
+})
+
+{
+ let saved: any = 'untouched'
+ const found = await checkForUpdate({
+ getSelf: dev, currentVersion: '1.0.0',
+ fetch: serving({ version: '1.1.0', url: 'https://example/rel', sha256: 'abc' }),
+ put: async (v: any) => { saved = v },
+ })
+ ok(found?.version === '1.1.0', `a newer release is reported (${found?.version})`)
+ ok(found?.url === 'https://example/rel', 'with where to get it')
+ ok(found?.sha256 === 'abc',
+ 'and the digest, which the person installing can check because the package is reproducible')
+ ok(saved?.version === '1.1.0', 'and it is stored, so the surfaces need no network of their own')
+}
+{
+ let saved: any = 'untouched'
+ const found = await checkForUpdate({
+ getSelf: dev, currentVersion: '1.1.0',
+ fetch: serving({ version: '1.1.0' }),
+ put: async (v: any) => { saved = v },
+ })
+ ok(found === null && saved === null, 'the same version reports nothing, and clears any old notice')
+}
+{
+ let saved: any = 'untouched'
+ const found = await checkForUpdate({
+ getSelf: dev, currentVersion: '1.2.0',
+ fetch: serving({ version: '1.1.0' }),
+ put: async (v: any) => { saved = v },
+ })
+ ok(found === null && saved === null,
+ 'a server BEHIND this copy reports nothing — a downgrade is not an update')
+}
+{
+ // The case that matters most: a store user must never be nagged, and must not
+ // cost a network request either.
+ let fetched = false
+ let saved: any = 'untouched'
+ const found = await checkForUpdate({
+ getSelf: store, currentVersion: '1.0.0',
+ fetch: async () => { fetched = true; return serving({ version: '9.9.9' })() },
+ put: async (v: any) => { saved = v },
+ })
+ ok(found === null, 'a store install is never told about a newer version')
+ ok(fetched === false, 'and never even asks — no request for the majority of users')
+ ok(saved === null, 'any notice from a previous unpacked life is cleared')
+}
+{
+ const found = await checkForUpdate({
+ getSelf: dev, currentVersion: '1.0.0',
+ fetch: async () => { throw new Error('offline') },
+ put: async () => {},
+ })
+ ok(found === null, 'being offline is silent — a broken courtesy must not look like a broken product')
+}
+{
+ const found = await checkForUpdate({
+ getSelf: dev, currentVersion: '1.0.0',
+ fetch: serving({ version: '2.0.0' }, false), // 404
+ put: async () => {},
+ })
+ ok(found === null, 'a non-200 is silent too')
+}
+{
+ const found = await checkForUpdate({
+ getSelf: dev, currentVersion: '1.0.0',
+ fetch: serving({ notes: 'nothing useful' }),
+ put: async () => {},
+ })
+ ok(found === null, 'a manifest with no version is ignored rather than half-believed')
+}
+{
+ // No identifiers, no query string, no version reported upward. The app's own
+ // update check promises this; the extension must not be quietly weaker.
+ let seen = ''
+ await checkForUpdate({
+ getSelf: dev, currentVersion: '1.0.0',
+ fetch: async (url: string) => { seen = url; return serving({ version: '1.0.0' })() },
+ put: async () => {},
+ })
+ ok(!seen.includes('?'), `the request carries no query string (${seen})`)
+ ok(!seen.includes('1.0.0'), 'and does not report which version is asking')
+ ok(seen.startsWith('https://'), 'over https')
+}
+
+// ---- the preference --------------------------------------------------------
+// Default ON, because an unpacked install has no other way to learn it is
+// behind and the app checks at launch by default too. Switchable, because this
+// repo has form on the other side — the v0.9.1 fix existed so an anonymous
+// visitor never phones home — and the audience that installs from GitHub is
+// exactly the one entitled to say no.
+{
+ ok(await autoCheckEnabled({ get: async () => undefined }),
+ 'absent means ON — a fresh install checks, which is the whole point')
+ ok(await autoCheckEnabled({ get: async () => true }), 'true is on')
+ ok(!(await autoCheckEnabled({ get: async () => false })), 'and false is off')
+}
+{
+ // OFF must mean nothing leaves the machine. Not "checks and hides the
+ // result" — that would be the same request with a quieter UI.
+ let fetched = false
+ const found = await checkForUpdate({
+ getSelf: dev, currentVersion: '1.0.0',
+ get: async () => false,
+ fetch: async () => { fetched = true; return serving({ version: '9.9.9' })() },
+ put: async () => {},
+ })
+ ok(found === null, 'with the preference off, nothing is reported')
+ ok(fetched === false, 'and NOTHING is requested — off means no traffic, not a hidden result')
+}
+{
+ // Pressing a button is consent, whatever the preference says. Otherwise the
+ // manual check silently does nothing and looks broken.
+ let fetched = false
+ const found = await checkForUpdate({
+ getSelf: dev, currentVersion: '1.0.0', force: true,
+ get: async () => false,
+ fetch: async () => { fetched = true; return serving({ version: '1.1.0' })() },
+ put: async () => {},
+ })
+ ok(fetched === true && found?.version === '1.1.0',
+ '"Check now" works with the preference off — pressing it IS the consent')
+}
+{
+ // And the preference must never override the install-type rule: a store user
+ // with the preference on still makes no request.
+ let fetched = false
+ await checkForUpdate({
+ getSelf: store, currentVersion: '1.0.0',
+ get: async () => true,
+ fetch: async () => { fetched = true; return serving({ version: '9.9.9' })() },
+ put: async () => {},
+ })
+ ok(fetched === false, 'a store install makes no request even with checking enabled')
+}
+
+console.log(`\n${checks - failures}/${checks} checks passed`)
+if (failures) process.exit(1)
diff --git a/tray/README.md b/tray/README.md
index 0c68e97d..abfd5ce6 100644
--- a/tray/README.md
+++ b/tray/README.md
@@ -98,6 +98,68 @@ mean more than "any document that saves the way Bento does":
picker per save would punish an app that saves often, and a download cannot
overwrite the user's original anyway — that is what the FSA path is for.
+### Finding the sender's file: route, don't search
+
+A `FileSystemDirectoryHandle` knows its own **name** but not its path, and no
+API exposes one — so a grant and a `sender.url` cannot be compared directly.
+The webext host used to resolve by walking the granted tree looking for a
+matching filename, depth-capped at 4 and declining whenever two files shared a
+name.
+
+It no longer searches. **A directory's name must appear in the path of every
+file inside it**, so the name locates the split point in the sender's path and
+everything after it is the route: one `getDirectoryHandle` per segment, then
+`getFileHandle`. O(path depth), nothing enumerated. Measured: a file inside a
+500-entry grant resolves with **zero directory scans**.
+
+Three things follow, and they are the reason for it:
+
+- a grant can be **any size**. A home directory costs what a decks folder costs,
+ which is what makes "grant everything" a reasonable thing to offer.
+- **several grants** are cheap — each attempt is a few lookups, so the store
+ holds a list (`dirs`), not one folder.
+- **two documents sharing a filename stop being ambiguous.** The old walk found
+ both and declined; only one route leads to one file. Anyone with per-client
+ folders hit that on every save.
+
+The split point is checked, not guessed: a wrong one fails at the first missing
+segment, and `resolve()` re-verifies the file it lands on against the sender's
+path regardless (the identity check that stopped a same-named file elsewhere
+from being overwritten). A grant covering a whole home directory raises the cost
+of a resolution bug, so that check matters more, not less.
+
+`findByName` survives as a fallback for paths the route cannot place.
+
+### The grant lapses on every browser restart
+
+MEASURED 2026-08-14: a `showDirectoryPicker` grant survives service-worker
+eviction — which is constant, and why nothing is cached between messages — but
+Chrome drops it back to `prompt` when the extension restarts **and when the
+browser restarts**. The HANDLE survives in IndexedDB; only the permission goes.
+
+So the recovery is `requestPermission()` on the handle already held — one
+confirmation, no folder to re-find — and it must happen on an **extension page**,
+because it needs a user gesture and the service worker has none. That is what
+the per-folder **Renew** button is. `background.js` only ever queries.
+
+**But Chrome's permission dialog offers "Allow on every visit"**, alongside
+"Allow this time", and it offers it to the EXTENSION origin — observed
+2026-08-14 on `chrome-extension://…/src/options.html`. So persistent File System
+Access permission is available here, and an earlier claim in this file that it
+was scoped to installed web apps was simply wrong.
+
+Whether "every visit" survives a full browser restart for an extension origin is
+NOT yet measured. Until it is, the UI says which button to choose and does not
+promise what follows. If it holds, the grant is once and for all. If it does
+not, the ceiling is one **Renew** click per browser session, since
+`chrome.downloads` can only write inside the downloads folder and durable access
+would then need a native messaging host — a separate decision, because it
+changes how the thing is distributed.
+
+The choice is the browser's to offer and the user's to make; nothing in the
+extension can pick it. All the code can do is point at the one that ends the
+chore.
+
### Which file a save targets
Bento only reaches a picker when it holds **no handle**; afterwards ⌘S, autosave
diff --git a/tray/webext/README.md b/tray/webext/README.md
index 90143b69..765830a0 100644
--- a/tray/webext/README.md
+++ b/tray/webext/README.md
@@ -36,6 +36,122 @@ can be shown to be the reviewed one.
Listing copy, permission justifications and the data-usage answers live in
`STORE.md`.
+## Releasing, and keeping unpacked installs current
+
+Two distribution routes, and only one of them updates itself.
+
+**Chrome Web Store and Edge Add-ons** update silently. Nothing to do.
+
+**GitHub, loaded unpacked** never updates. Chrome ignores `update_url` for a
+development install — it is running from a directory on disk, and nothing will
+rewrite that directory. Self-hosting a `.crx` is not a way round it either:
+Chrome refuses off-store installs on Windows and macOS.
+
+So the extension tells those users instead. `src/update.js` asks
+`chrome.management.getSelf()` for `installType` — which needs **no permission** —
+and only a non-`normal` install ever checks. Store users are never asked and
+never see a notice they cannot act on. The check is a GET for a static JSON file
+with no identifiers and no query string; it can report, link, and nothing else.
+
+**On by default, and switchable.** On, because an unpacked install has no other
+way to learn it is behind, and because the app itself checks at launch by
+default (`kernel/src/update.ts`). Switchable, because this repo has form on the
+other side — the v0.9.1 fix existed so an anonymous visitor never phones home —
+and the audience that installs from GitHub is exactly the one entitled to say
+no. The switch is in Settings, next to what it does, and OFF means no request is
+made at all rather than a result quietly discarded. **Check now** still works
+when it is off: pressing a button is the consent the preference stands in for.
+
+### What an unpacked user has to do, and the way it goes wrong
+
+An unpacked extension is identified by its **directory path**. So the obvious
+upgrade — extract the new zip somewhere convenient, "Load unpacked" from there —
+produces a DIFFERENT extension: different id, different origin, empty
+IndexedDB. No granted folders, no learned paths, no preferences, and the old
+copy still installed beside it. The user lands on the first-run screen having
+done the natural thing.
+
+The safe procedure, which the notice spells out as numbered steps:
+
+1. Download the zip from the release.
+2. Replace the files **in the folder it was originally loaded from**.
+3. `chrome://extensions` → **Reload** on Bento Tray.
+
+Same path, same id, so the grants and everything else survive. The first-run
+screen also carries a note for anyone who already got it wrong, because "an
+unpacked install with no folders" is exactly what a botched upgrade looks like
+and nothing can detect it from inside the new copy — the data is intact under
+the old id.
+
+Note that extracting over an existing folder leaves files a release has since
+DELETED. Harmless (the manifest does not name them) but untidy; emptying the
+folder first is cleaner, and keeps the path, which is the part that matters.
+
+### To cut a release
+
+```bash
+node scripts/pack-webext.mjs
+```
+
+That writes two things into `dist/`:
+
+- `bento-tray-<version>.zip` — upload to both stores.
+- `tray-release.json` — publish at `https://bento.page/releases/tray/manifest.json`.
+
+The JSON carries the version, the release URL, and the **sha256 of the zip just
+built**. It is emitted rather than hand-written because a copied hash goes stale
+in silence, and it is publishable at all because the package is byte-reproducible
+— anyone can rebuild from source and confirm the zip they downloaded is the one
+that was reviewed.
+
+Bump `manifest.json`'s `version` before packing; the store rejects a re-upload of
+an existing version, and unpacked users compare against exactly that number.
+
+## Two surfaces
+
+- **Toolbar click → the library** (`src/home.html`): browsing and managing.
+ An existing tab is focused rather than duplicated. This only works because the
+ manifest declares NO `default_popup` — declaring one makes the click open it
+ and `action.onClicked` never fires.
+- **`Alt+B`, or right-click in a document → the panel** (`src/panel.html`):
+ switching documents while working in one. It was a popup; a popup dies when it
+ loses focus, which is exactly when you click into the document you switched
+ to.
+
+`sidePanel.open()` must be called **synchronously** inside the gesture that
+triggered it (Chrome 116+, this extension's floor). An `await` before it loses
+the gesture and Chrome refuses without saying so — which is why the lapsed-grant
+notification opens the library instead: it is handled after an await.
+
+## Icons
+
+`icons/icon.svg` is the source of everything visual: the favicon for the
+extension's own pages, and the four PNGs Chrome takes for the toolbar action
+icon. It carries a corner radius, unlike `tray/assets/tray-icon.svg`, which is
+square because iOS applies its own squircle mask.
+
+The PNGs are exports of it and must be regenerated rather than edited:
+
+```bash
+cd tray/webext/icons
+for n in 16 32 48 128; do
+ printf '<!doctype html><meta charset="utf-8"><style>html,body{margin:0;background:transparent}svg{display:block;width:%dpx;height:%dpx}</style>' "$n" "$n" > /tmp/i.html
+ sed -n '/<svg/,$p' icon.svg >> /tmp/i.html
+ "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless \
+ --disable-gpu --hide-scrollbars --default-background-color=00000000 \
+ --window-size=$n,$n --screenshot=icon-$n.png /tmp/i.html
+done
+```
+
+Two things `pack-webext.mjs` refuses, both of which have already happened:
+
+- **A PNG with no alpha channel.** The originals were RGB, so opaque squares by
+ construction, and no radius anywhere could round the toolbar.
+- **An SVG that is not well-formed XML.** This command lives here rather than in
+ a comment inside `icon.svg` because an XML comment may not contain a double
+ hyphen, and every flag above has one. Pasting it in there made the file
+ malformed, and the mark rendered as a broken image on every surface.
+
## Distribution
**The app stores are the main channel** — Chrome Web Store, Edge Add-ons, and
diff --git a/tray/webext/STORE.md b/tray/webext/STORE.md
index 13af8869..bdc74f5a 100644
--- a/tray/webext/STORE.md
+++ b/tray/webext/STORE.md
@@ -141,3 +141,69 @@ A small promo tile (440×280) is optional but improves placement.
reading is better than a handled unknown)
- [ ] Screenshots
- [ ] Developer account (one-off fee)
+
+### Where the folder permission lives, and how to take it back
+
+Bento Tray never has standing access to your disk. It can only write inside
+folders you pick, and only to the file a page was actually opened from.
+
+Two things are remembered, and only one of them is the access:
+
+- **the folder you chose**, stored by the extension. This is the capability:
+ without it there is no object to write through, and another can only come
+ from you picking a folder again. **Remove**, in the extension's options,
+ deletes it — that is a real withdrawal of access.
+- **Chrome's permission to edit files**, stored by Chrome against this
+ extension. On its own it grants nothing. It means only that if you pick that
+ same folder again, Chrome may not ask a second time.
+
+Chrome's usual controls for this — the address-bar icon's *Remove access*, and
+the per-site *File editing* list — are part of the site-settings surface for a
+website origin, and that surface is not offered for `chrome-extension://` pages;
+the address-bar chip there reports only "You're viewing an extension page".
+Observed 2026-08-14. So the extension's own folder list is the place access is
+withdrawn, and it is written to be exactly that.
+
+## What it looks like
+
+Open the toolbar icon and you get **your documents** — page-one thumbnails,
+real titles, newest first — from every folder you have granted. Click one to
+open it. `+ New document` fetches the current signed Bento release and writes a
+fresh document into your folder, so it is the same version everyone else has
+that day; nothing is bundled inside the extension to go stale.
+
+Thumbnails are not generated by the extension. Every Bento document already
+carries a still render of its first page, written on each save so that file
+managers can show it. This reads that, and renders it inert in a sandboxed
+frame with no scripts. A password-protected document deliberately carries no
+such render — a plaintext title page beside the ciphertext is exactly what the
+password prevents — so those show a lock instead.
+
+Permission state lives in one line at the bottom and stays quiet while things
+work.
+
+### Does it talk to the network?
+
+Once, and only for copies the browser will never update.
+
+An extension installed from a store updates itself, so it never checks anything
+and never makes a request. A copy loaded unpacked from GitHub cannot update
+itself — Chrome ignores `update_url` for a development install — so it asks
+`bento.page` for a static JSON file when the browser starts, to see whether a
+newer release exists.
+
+That request carries no identifiers, no query string, and not even the version
+asking: the comparison happens on your machine. It can show a notice and link to
+the release. It cannot install anything.
+
+It is on by default for those copies and can be turned off in Settings, where
+turning it off means no request is made at all.
+
+Nothing about your documents ever leaves your machine, under any setting.
+
+### Updating a copy loaded from GitHub
+
+Replace the files **in the folder you loaded it from**, then press Reload on
+`chrome://extensions`. Same folder matters: Chrome identifies an unpacked
+extension by its path, so loading a new copy from a different folder creates a
+second, separate extension — and your granted folders stay with the first one.
diff --git a/tray/webext/_locales/ar/messages.json b/tray/webext/_locales/ar/messages.json
new file mode 100644
index 00000000..11d9b8b9
--- /dev/null
+++ b/tray/webext/_locales/ar/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "احفظ مستند Bento مرة أخرى في الملف الذي فتحته، دون سؤال عن الوجهة."
+ },
+ "navAll": {
+ "message": "كل المستندات"
+ },
+ "navFolders": {
+ "message": "المجلدات"
+ },
+ "navHelp": {
+ "message": "المساعدة ونبذة"
+ },
+ "navSettings": {
+ "message": "الإعدادات"
+ },
+ "addFolder": {
+ "message": "+ إضافة مجلد…"
+ },
+ "searchDocs": {
+ "message": "البحث في المستندات"
+ },
+ "searchDocsSlash": {
+ "message": "البحث في المستندات /"
+ },
+ "sortTitle": {
+ "message": "الترتيب"
+ },
+ "sortRecent": {
+ "message": "المعدَّلة حديثًا"
+ },
+ "sortName": {
+ "message": "الاسم"
+ },
+ "sortFolder": {
+ "message": "المجلد"
+ },
+ "newDocument": {
+ "message": "+ مستند جديد"
+ },
+ "browseAll": {
+ "message": "تصفح الكل"
+ },
+ "reconnectFolders": {
+ "message": "إعادة ربط المجلدات"
+ },
+ "primeIntro": {
+ "message": "سيسألك Chrome بعد قليل. اختر الخيار الأوسط:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — أحد المجلدات يحتاج إلى إعادة ربط"
+ },
+ "notifyLapsedTitle": {
+ "message": "يحتاج Bento Tray إلى إعادة ربط"
+ },
+ "notifyLapsedBody": {
+ "message": "سحب Chrome الإذن الممنوح لمجلد. وإلى أن يُستعاد، سيسألك كل حفظ عن مكان وضع الملف."
+ },
+ "reconnect": {
+ "message": "إعادة الربط"
+ },
+ "ctxOpenPanel": {
+ "message": "فتح لوحة Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "لا توجد بعد مستندات Bento في مجلداتك."
+ },
+ "noMatches": {
+ "message": "لا شيء يطابق «$1»"
+ },
+ "rowUnplacedTip": {
+ "message": "افتح أي مستند في $1 مرة واحدة من Finder، فيصبح كل ما في ذلك المجلد قابلًا للفتح من هنا."
+ },
+ "encrypted": {
+ "message": "محمي بكلمة مرور"
+ },
+ "notSavedYet": {
+ "message": "لم يُحفظ بعد"
+ },
+ "fileAccessOffShort": {
+ "message": "الوصول إلى الملفات المحلية معطَّل"
+ },
+ "noFoldersYet": {
+ "message": "لا توجد مجلدات بعد"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 مجلد يحتاج إلى إعادة ربط"
+ },
+ "statusOneFolder": {
+ "message": "$1 مجلد · يحفظ في مكانه"
+ },
+ "statusFolders": {
+ "message": "$1 مجلدات · تحفظ في مكانها"
+ },
+ "renewNotOffered": {
+ "message": "لم يعرض Chrome استعادته"
+ },
+ "renewTryAfterRestart": {
+ "message": "أعد المحاولة بعد إعادة تشغيل Chrome"
+ },
+ "fetchingLatest": {
+ "message": "جارٍ جلب أحدث إصدار من Bento…"
+ },
+ "created": {
+ "message": "أُنشئ $1"
+ },
+ "panelUnplaced": {
+ "message": "يمكن قراءة <b>$1</b>$2 لكن لا يمكن فتحه بعد — لا يخبر Chrome أي امتداد بموضع المجلد على القرص. يمكن لـ<b>تصفح الكل</b> إيجادها بنقرة واحدة."
+ },
+ "andMore": {
+ "message": " و$1 غيرها"
+ },
+ "agoJustNow": {
+ "message": "الآن"
+ },
+ "agoMinutes": {
+ "message": "قبل $1 دقيقة"
+ },
+ "agoHour": {
+ "message": "قبل $1 ساعة"
+ },
+ "agoHours": {
+ "message": "قبل $1 ساعات"
+ },
+ "agoDay": {
+ "message": "قبل $1 يوم"
+ },
+ "agoDays": {
+ "message": "قبل $1 أيام"
+ },
+ "searchScope": {
+ "message": "يبحث النظام في العناوين وأسماء الملفات والمجلدات وفي الكلمات داخل المستندات."
+ },
+ "folderEmpty": {
+ "message": "لا شيء في هذا المجلد بعد"
+ },
+ "folderEmptyHint": {
+ "message": "يضع <b>+ مستند جديد</b> واحدًا جديدًا هنا."
+ },
+ "cardUnplacedTip": {
+ "message": "لا يعرف Bento Tray بعد أين يقع $1 على القرص. استخدم «ابحث عن مجلداتي»، أو افتح أي مستند فيه من Finder مرة واحدة."
+ },
+ "cardRenamedTip": {
+ "message": "$1 مستند Bento باسم آخر. يُفتح من هنا، لكن الحفظ سيسأل عن وجهة — فالحفظ في المكان لا يتعرف إلا على الملفات المنتهية بـ‎.bento.html."
+ },
+ "badgeRenamed": {
+ "message": "مسمّى ‎.html بدل ‎.bento.html — يُفتح من هنا، لكن الحفظ سيسأل عن وجهة."
+ },
+ "menuOpen": {
+ "message": "فتح"
+ },
+ "menuDuplicate": {
+ "message": "تكرار"
+ },
+ "menuRename": {
+ "message": "إعادة تسمية…"
+ },
+ "menuCopyPath": {
+ "message": "نسخ المسار"
+ },
+ "duplicatedAs": {
+ "message": "تم التكرار باسم $1"
+ },
+ "renamePrompt": {
+ "message": "إعادة تسمية المستند"
+ },
+ "renamedTo": {
+ "message": "أُعيدت التسمية إلى $1"
+ },
+ "pathCopied": {
+ "message": "نُسخ المسار"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — لم يُفتح بعد"
+ },
+ "setupTitle": {
+ "message": "أمران وتكون جاهزًا"
+ },
+ "setupLead": {
+ "message": "بعد ذلك، يكتب ⌘S في مستند فتحته بنقرة مزدوجة مباشرةً إلى الملف نفسه — دون أي سؤال عن الوجهة، أبدًا."
+ },
+ "chooseFolder": {
+ "message": "اختيار مجلد…"
+ },
+ "setupStep1": {
+ "message": "اختر المجلد الذي توجد فيه مستنداتك"
+ },
+ "setupStep1Note": {
+ "message": "مجلد واحد واسع يكفي عادةً — فهو يشمل كل ما بداخله."
+ },
+ "setupStep2": {
+ "message": "فعّل الوصول إلى الملفات المحلية"
+ },
+ "setupStep2Note": {
+ "message": "في <code>chrome://extensions</code> ← Bento Tray ← <b>السماح بالوصول إلى عناوين URL للملفات</b>. لا يسمح Chrome لأي امتداد بتفعيل هذا بنفسه."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>هل رقّيت وتوقعت أن تجد مجلداتك هنا؟</b> يُعرَّف الامتداد غير المحزوم بمسار مجلده، لذا فإن نسخة جديدة محمَّلة من مجلد آخر تُعد امتدادًا مختلفًا. مجلداتك ما زالت ممنوحة للنسخة القديمة. بدلًا من ذلك، استبدل الملفات في المجلد الأصلي واضغط <b>إعادة التحميل</b> في <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>الوصول إلى الملفات المحلية معطَّل</b> — لن يُحفظ شيء في مكانه حتى يُفعَّل. فعّل <b>السماح بالوصول إلى عناوين URL للملفات</b> في <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 مجلد يحتاج إلى إعادة ربط.</b> أعد ربطه من <b>الإعدادات</b>، واختر <b>السماح في كل زيارة</b> — وهو الخيار الوحيد الذي يدوم."
+ },
+ "noticeUnplaced": {
+ "message": "يمكن إدراج <b>$1</b> لكن لا يمكن فتحه بعد — لا يخبر Chrome أي امتداد أبدًا بموضع المجلد على القرص."
+ },
+ "findFolders": {
+ "message": "ابحث عن مجلداتي"
+ },
+ "looking": {
+ "message": "جارٍ البحث…"
+ },
+ "findDeclined": {
+ "message": "<b>لا بأس.</b> بدلًا من ذلك افتح أي مستند في $1 من Finder مرة واحدة — ستلاحظ هذه الصفحة ذلك."
+ },
+ "foundFolder": {
+ "message": "عُثر على $1 مجلد"
+ },
+ "foundFolders": {
+ "message": "عُثر على $1 مجلدات"
+ },
+ "foundNothing": {
+ "message": "لا شيء في السجل بعد — افتح مستندًا واحدًا من Finder"
+ },
+ "setFoldersSub": {
+ "message": "المستندات الموجودة فيها تُحفظ مباشرةً إلى ملفاتها دون سؤال عن الوجهة. والمجلد يشمل كل ما بداخله."
+ },
+ "noneYet": {
+ "message": "لا شيء بعد."
+ },
+ "savesInPlace": {
+ "message": "يحفظ في مكانه"
+ },
+ "needsReconnecting": {
+ "message": "يحتاج إلى إعادة ربط"
+ },
+ "reconnectTip": {
+ "message": "سيطلب Chrome الإذن لاستعادة هذا المجلد. «عدم السماح» يُسقطه، وبعدها ينتظر Chrome إعادة تشغيل على الأقل قبل أن يسأل مجددًا."
+ },
+ "remove": {
+ "message": "إزالة"
+ },
+ "removeTip": {
+ "message": "يسحب الوصول. قد يظل Chrome متذكرًا الإذن، لذا قد لا يسأل مرة أخرى عند إعادة إضافة المجلد."
+ },
+ "setAccessTitle": {
+ "message": "الوصول إلى الملفات المحلية"
+ },
+ "setAccessSub": {
+ "message": "لا يسمح Chrome لأي امتداد بتفعيل هذا بنفسه، ولا يعمل شيء بدونه."
+ },
+ "stateOn": {
+ "message": "مفعَّل"
+ },
+ "stateOff": {
+ "message": "معطَّل"
+ },
+ "stateUnknown": {
+ "message": "غير معروف"
+ },
+ "accessOnNote": {
+ "message": "يستطيع Bento Tray قراءة الصفحات التي فتحتها من القرص."
+ },
+ "accessOffNote": {
+ "message": "افتح chrome://extensions، وابحث عن Bento Tray، وفعّل «السماح بالوصول إلى عناوين URL للملفات»."
+ },
+ "accessUnknownNote": {
+ "message": "لا يبلّغ هذا المتصفح عن الحالة. إذا ظل الحفظ يسأل، فتحقق من ذلك في chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "الإصدار"
+ },
+ "setVersionUnpacked": {
+ "message": "حُمِّلت هذه النسخة غير محزومة، لذا لن يحدّثها Chrome أبدًا."
+ },
+ "setVersionStore": {
+ "message": "مثبَّت من المتجر، لذا يحدّث نفسه."
+ },
+ "versionAvailable": {
+ "message": "$1 متاح"
+ },
+ "versionUpToDate": {
+ "message": "محدَّث حتى آخر فحص"
+ },
+ "versionManaged": {
+ "message": "يبقيه المتصفح محدَّثًا"
+ },
+ "getIt": {
+ "message": "احصل عليه"
+ },
+ "checkNow": {
+ "message": "افحص الآن"
+ },
+ "autoCheckPref": {
+ "message": "<b>ابحث عن إصدار جديد عند بدء تشغيل المتصفح.</b><br>طلب واحد إلى bento.page لملف ثابت. لا يرسل أي معرّفات ولا رقم إصدار ولا شيئًا عن مستنداتك — فالمقارنة تجري هنا. عطّله فلن يُطلب شيء أبدًا؛ ويظل <b>افحص الآن</b> يعمل."
+ },
+ "expectedSha": {
+ "message": "قيمة SHA-256 المتوقعة للملف المضغوط: $1"
+ },
+ "setReachTitle": {
+ "message": "ما الذي يصل إليه"
+ },
+ "setReachSub": {
+ "message": "المجلدات أعلاه فقط، والملف الذي فُتحت منه الصفحة فعليًا فقط. لا يُرفع شيء ولا يُقرأ شيء في أي مكان آخر."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 متاح.</b> حُمِّلت هذه النسخة غير محزومة، لذا لن يحدّثها Chrome أبدًا."
+ },
+ "updateStep1": {
+ "message": "نزّله من GitHub"
+ },
+ "updateStep2": {
+ "message": "استبدل الملفات <b>في المجلد الذي حمّلته منه</b> — المجلد نفسه، وإلا عدّه Chrome امتدادًا مختلفًا ولن تنتقل معه المجلدات الممنوحة"
+ },
+ "updateStep3": {
+ "message": "افتح <code>chrome://extensions</code> واضغط <b>إعادة التحميل</b> على Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "جارٍ جلب $1…"
+ },
+ "createdIn": {
+ "message": "أُنشئ $1 ($2) في $3"
+ },
+ "intoFolder": {
+ "message": "في $1"
+ },
+ "helpWhatTitle": {
+ "message": "ما الذي يفعله Bento Tray"
+ },
+ "helpWhatSub": {
+ "message": "مستند Bento هو ملف HTML واحد يحمل محرّره معه. وعند فتحه مباشرةً من القرص لا يسمح له المتصفح بالكتابة إلى نفسه — فيسألك الحفظ في كل مرة عن مكان وضعه. وBento Tray هو ما يزيل هذا السؤال."
+ },
+ "tourSaveTitle": {
+ "message": "الحفظ في المكان"
+ },
+ "tourSaveBody": {
+ "message": "يكتب ⌘S مباشرةً إلى الملف الذي فتحته، دون أي مربع حوار. والحفظ التلقائي والتحديثات في المكان تسلك الطريق نفسه."
+ },
+ "tourFindTitle": {
+ "message": "اعثر على مستنداتك"
+ },
+ "tourFindBody": {
+ "message": "كل مستند Bento في مجلداتك، بعنوانه الحقيقي وصورة لصفحته الأولى. ويشمل البحث ما هو مكتوب داخلها."
+ },
+ "tourSwitchTitle": {
+ "message": "بدّل وأنت تعمل"
+ },
+ "tourSwitchBody": {
+ "message": "اضغط <kbd>Alt</kbd>+<kbd>B</kbd>، أو انقر بالزر الأيمن داخل مستند، لتظهر لوحة إلى جانبه."
+ },
+ "tourNewTitle": {
+ "message": "أنشئ مستندًا جديدًا"
+ },
+ "tourNewBody": {
+ "message": "يجلب <b>+ مستند جديد</b> الإصدار الحالي من Slides أو Spaces أو Dash ويضع مستندًا جديدًا في مجلدك."
+ },
+ "helpNeedsTitle": {
+ "message": "ما يحتاجه منك"
+ },
+ "helpNeedsSub": {
+ "message": "أمران، وكلاهما خارج قدرة هذا الامتداد على ترتيبه."
+ },
+ "helpFolder": {
+ "message": "مجلد"
+ },
+ "helpFolderGranted": {
+ "message": "$1 ممنوح — المستندات داخلها تُحفظ في مكانها"
+ },
+ "helpFolderNone": {
+ "message": "لم يُختر بعد. مجلد واحد واسع يشمل كل ما بداخله."
+ },
+ "helpAccessOff": {
+ "message": "معطَّل. فعّل <b>السماح بالوصول إلى عناوين URL للملفات</b> في <code>chrome://extensions</code> — فلا يستطيع أي امتداد تفعيل هذا بنفسه."
+ },
+ "helpAccessUnknown": {
+ "message": "لا يبلّغ هذا المتصفح عن الحالة. إذا ظل الحفظ يسأل، فتحقق من ذلك في <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "مفعَّل — يستطيع Bento Tray قراءة الصفحات التي فتحتها من القرص."
+ },
+ "helpNeverTitle": {
+ "message": "ما لا يفعله أبدًا"
+ },
+ "helpNeverSub": {
+ "message": "يقرأ ويكتب داخل المجلدات أعلاه فقط، وفي الملف الذي فُتحت منه الصفحة فعليًا فقط — والمتصفح هو من يحدد أيّها، فلا يستطيع مستند أن يسمّي ملف شخص آخر. ولا يُرفع أي شيء عن مستنداتك إلى أي مكان، ولا يملك الامتداد خادمًا يرفعها إليه أصلًا."
+ },
+ "helpAboutTitle": {
+ "message": "نبذة"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · جزء من مشروع Bento · مرخّص برخصة MIT"
+ },
+ "linkSource": {
+ "message": "المصدر على GitHub"
+ },
+ "linkIssues": {
+ "message": "الإبلاغ عن مشكلة"
+ },
+ "linkReleases": {
+ "message": "الإصدارات"
+ },
+ "primeMiddle": {
+ "message": "الخيار الذي يدوم"
+ },
+ "primeNote": {
+ "message": "الخياران الآخران يعملان أيضًا، لكن Chrome يسأل من جديد — عند كل إعادة تشغيل بالنسبة للأول، وبعد انتظار بالنسبة للأخير."
+ }
+}
diff --git a/tray/webext/_locales/bn/messages.json b/tray/webext/_locales/bn/messages.json
new file mode 100644
index 00000000..7e1a2d17
--- /dev/null
+++ b/tray/webext/_locales/bn/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "যে ফাইলটি খুলেছেন সেখানেই Bento নথি ফিরিয়ে সংরক্ষণ করুন, গন্তব্য জিজ্ঞাসা ছাড়াই।"
+ },
+ "navAll": {
+ "message": "সব নথি"
+ },
+ "navFolders": {
+ "message": "ফোল্ডার"
+ },
+ "navHelp": {
+ "message": "সহায়তা ও পরিচিতি"
+ },
+ "navSettings": {
+ "message": "সেটিংস"
+ },
+ "addFolder": {
+ "message": "+ ফোল্ডার যোগ করুন…"
+ },
+ "searchDocs": {
+ "message": "নথি খুঁজুন"
+ },
+ "searchDocsSlash": {
+ "message": "নথি খুঁজুন /"
+ },
+ "sortTitle": {
+ "message": "সাজান"
+ },
+ "sortRecent": {
+ "message": "সম্প্রতি পরিবর্তিত"
+ },
+ "sortName": {
+ "message": "নাম"
+ },
+ "sortFolder": {
+ "message": "ফোল্ডার"
+ },
+ "newDocument": {
+ "message": "+ নতুন নথি"
+ },
+ "browseAll": {
+ "message": "সব দেখুন"
+ },
+ "reconnectFolders": {
+ "message": "ফোল্ডার আবার যুক্ত করুন"
+ },
+ "primeIntro": {
+ "message": "Chrome এখনই জিজ্ঞাসা করবে। মাঝের বিকল্পটি বেছে নিন:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — একটি ফোল্ডার আবার যুক্ত করা দরকার"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray আবার যুক্ত করা দরকার"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome একটি ফোল্ডারের অনুমতি প্রত্যাহার করেছে। সেটি ফিরে না আসা পর্যন্ত প্রতিবার সংরক্ষণে জিজ্ঞাসা করা হবে ফাইলটি কোথায় রাখবেন।"
+ },
+ "reconnect": {
+ "message": "আবার যুক্ত করুন"
+ },
+ "ctxOpenPanel": {
+ "message": "Bento Tray প্যানেল খুলুন"
+ },
+ "panelEmpty": {
+ "message": "আপনার ফোল্ডারে এখনও কোনো Bento নথি নেই।"
+ },
+ "noMatches": {
+ "message": "“$1”-এর সঙ্গে কিছুই মেলেনি"
+ },
+ "rowUnplacedTip": {
+ "message": "$1-এর যেকোনো একটি নথি Finder থেকে একবার খুলুন, তাহলে ওই ফোল্ডারের সবকিছু এখান থেকেই খোলা যাবে।"
+ },
+ "encrypted": {
+ "message": "পাসওয়ার্ড-সুরক্ষিত"
+ },
+ "notSavedYet": {
+ "message": "এখনও সংরক্ষিত হয়নি"
+ },
+ "fileAccessOffShort": {
+ "message": "স্থানীয় ফাইল অ্যাক্সেস বন্ধ"
+ },
+ "noFoldersYet": {
+ "message": "এখনও কোনো ফোল্ডার নেই"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1টি ফোল্ডার আবার যুক্ত করা দরকার"
+ },
+ "statusOneFolder": {
+ "message": "$1টি ফোল্ডার · জায়গাতেই সংরক্ষণ করে"
+ },
+ "statusFolders": {
+ "message": "$1টি ফোল্ডার · জায়গাতেই সংরক্ষণ করে"
+ },
+ "renewNotOffered": {
+ "message": "Chrome সেটি ফিরিয়ে দেওয়ার প্রস্তাব দেয়নি"
+ },
+ "renewTryAfterRestart": {
+ "message": "Chrome আবার চালু করে ফের চেষ্টা করুন"
+ },
+ "fetchingLatest": {
+ "message": "সর্বশেষ Bento আনা হচ্ছে…"
+ },
+ "created": {
+ "message": "$1 তৈরি হয়েছে"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 পড়া গেলেও এখনও খোলা যাচ্ছে না — ফোল্ডারটি ডিস্কের কোথায় আছে Chrome তা কোনো এক্সটেনশনকে জানায় না। <b>সব দেখুন</b> এক ক্লিকেই সেগুলো খুঁজে দেয়।"
+ },
+ "andMore": {
+ "message": " এবং আরও $1টি"
+ },
+ "agoJustNow": {
+ "message": "এইমাত্র"
+ },
+ "agoMinutes": {
+ "message": "$1 মিনিট আগে"
+ },
+ "agoHour": {
+ "message": "$1 ঘণ্টা আগে"
+ },
+ "agoHours": {
+ "message": "$1 ঘণ্টা আগে"
+ },
+ "agoDay": {
+ "message": "$1 দিন আগে"
+ },
+ "agoDays": {
+ "message": "$1 দিন আগে"
+ },
+ "searchScope": {
+ "message": "খোঁজ শিরোনাম, ফাইলের নাম, ফোল্ডার এবং নথির ভেতরের শব্দ — সবই দেখে।"
+ },
+ "folderEmpty": {
+ "message": "এই ফোল্ডারে এখনও কিছু নেই"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ নতুন নথি</b> এখানে একটি নতুন নথি রাখে।"
+ },
+ "cardUnplacedTip": {
+ "message": "$1 ডিস্কের কোথায় আছে Bento Tray এখনও জানে না। “আমার ফোল্ডার খুঁজুন” ব্যবহার করুন, কিংবা এর ভেতরের কোনো নথি Finder থেকে একবার খুলুন।"
+ },
+ "cardRenamedTip": {
+ "message": "$1 হলো অন্য নামে থাকা একটি Bento নথি। এটি এখান থেকে খোলে, তবে সংরক্ষণের সময় গন্তব্য জিজ্ঞাসা করা হবে — জায়গাতেই সংরক্ষণ কেবল .bento.html দিয়ে শেষ হওয়া ফাইল চেনে।"
+ },
+ "badgeRenamed": {
+ "message": ".bento.html-এর বদলে .html নাম — এখান থেকে খোলে, তবে সংরক্ষণের সময় গন্তব্য জিজ্ঞাসা করা হবে।"
+ },
+ "menuOpen": {
+ "message": "খুলুন"
+ },
+ "menuDuplicate": {
+ "message": "অনুলিপি করুন"
+ },
+ "menuRename": {
+ "message": "নাম বদলান…"
+ },
+ "menuCopyPath": {
+ "message": "পাথ কপি করুন"
+ },
+ "duplicatedAs": {
+ "message": "$1 নামে অনুলিপি হয়েছে"
+ },
+ "renamePrompt": {
+ "message": "নথির নাম বদলান"
+ },
+ "renamedTo": {
+ "message": "নাম বদলে $1 করা হয়েছে"
+ },
+ "pathCopied": {
+ "message": "পাথ কপি হয়েছে"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — এখনও খোলা হয়নি"
+ },
+ "setupTitle": {
+ "message": "দুটি কাজ, তারপরেই তৈরি"
+ },
+ "setupLead": {
+ "message": "এরপর ডাবল-ক্লিক করে খোলা নথিতে ⌘S সরাসরি সেই ফাইলেই লেখে — গন্তব্য আর কখনও জিজ্ঞাসা করা হবে না।"
+ },
+ "chooseFolder": {
+ "message": "ফোল্ডার বাছুন…"
+ },
+ "setupStep1": {
+ "message": "আপনার নথি যে ফোল্ডারে থাকে সেটি বাছুন"
+ },
+ "setupStep1Note": {
+ "message": "সাধারণত একটি বড় ফোল্ডারই যথেষ্ট — এর ভেতরের সবকিছু এতে ধরা পড়ে।"
+ },
+ "setupStep2": {
+ "message": "স্থানীয় ফাইল অ্যাক্সেস চালু করুন"
+ },
+ "setupStep2Note": {
+ "message": "<code>chrome://extensions</code> → Bento Tray → <b>ফাইল URL-এ অ্যাক্সেসের অনুমতি দিন</b>। Chrome কোনো এক্সটেনশনকে এটি নিজে চালু করতে দেয় না।"
+ },
+ "setupUpgradeNote": {
+ "message": "<b>আপগ্রেড করেছেন আর ভেবেছিলেন ফোল্ডারগুলো এখানেই থাকবে?</b> আনপ্যাকড এক্সটেনশন চেনা যায় তার ফোল্ডার পাথ দিয়ে, তাই অন্য ফোল্ডার থেকে লোড করা নতুন অনুলিপি আলাদা একটি এক্সটেনশন। আপনার ফোল্ডারগুলো এখনও পুরোনোটিরই। বরং মূল ফোল্ডারের ফাইলগুলো বদলে <code>chrome://extensions</code>-এ <b>পুনরায় লোড করুন</b> চাপুন।"
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>স্থানীয় ফাইল অ্যাক্সেস বন্ধ</b> — চালু না হওয়া পর্যন্ত কিছুই জায়গাতে সংরক্ষিত হবে না। <code>chrome://extensions</code>-এ <b>ফাইল URL-এ অ্যাক্সেসের অনুমতি দিন</b> চালু করুন।"
+ },
+ "noticeLapsed": {
+ "message": "<b>$1টি ফোল্ডার আবার যুক্ত করা দরকার।</b> <b>সেটিংস</b>-এ গিয়ে আবার যুক্ত করুন এবং <b>প্রতিবার অনুমতি দিন</b> বাছুন — একমাত্র এই বিকল্পটিই টেকে।"
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> তালিকায় দেখানো গেলেও এখনও খোলা যাচ্ছে না — ফোল্ডারটি ডিস্কের কোথায় আছে Chrome তা কোনো এক্সটেনশনকে কখনও জানায় না।"
+ },
+ "findFolders": {
+ "message": "আমার ফোল্ডার খুঁজুন"
+ },
+ "looking": {
+ "message": "খোঁজা হচ্ছে…"
+ },
+ "findDeclined": {
+ "message": "<b>কোনো অসুবিধা নেই।</b> বরং $1-এর একটি নথি Finder থেকে একবার খুলুন — এই পাতাটি টের পাবে।"
+ },
+ "foundFolder": {
+ "message": "$1টি ফোল্ডার পাওয়া গেছে"
+ },
+ "foundFolders": {
+ "message": "$1টি ফোল্ডার পাওয়া গেছে"
+ },
+ "foundNothing": {
+ "message": "ইতিহাসে এখনও কিছু নেই — Finder থেকে একটি নথি খুলুন"
+ },
+ "setFoldersSub": {
+ "message": "এগুলোর ভেতরের নথি গন্তব্য জিজ্ঞাসা ছাড়াই সরাসরি ফাইলেই সংরক্ষিত হয়। একটি ফোল্ডার তার ভেতরের সবকিছু ধরে।"
+ },
+ "noneYet": {
+ "message": "এখনও কিছু নেই।"
+ },
+ "savesInPlace": {
+ "message": "জায়গাতেই সংরক্ষণ করে"
+ },
+ "needsReconnecting": {
+ "message": "আবার যুক্ত করা দরকার"
+ },
+ "reconnectTip": {
+ "message": "Chrome এই ফোল্ডারটি ফিরিয়ে দেওয়ার অনুমতি চাইবে। “অনুমতি দেবেন না” সেটি ছেড়ে দেয়, আর তারপর Chrome আবার জিজ্ঞাসা করার আগে অন্তত একবার পুনরায় চালুর অপেক্ষা করে।"
+ },
+ "remove": {
+ "message": "সরান"
+ },
+ "removeTip": {
+ "message": "অ্যাক্সেস প্রত্যাহার করে। Chrome অনুমতিটি মনে রাখতে পারে, তাই ফোল্ডারটি আবার যোগ করলে হয়তো কিছুই জিজ্ঞাসা করা হবে না।"
+ },
+ "setAccessTitle": {
+ "message": "স্থানীয় ফাইল অ্যাক্সেস"
+ },
+ "setAccessSub": {
+ "message": "Chrome কোনো এক্সটেনশনকে এটি নিজে চালু করতে দেয় না, আর এটি ছাড়া কিছুই কাজ করে না।"
+ },
+ "stateOn": {
+ "message": "চালু"
+ },
+ "stateOff": {
+ "message": "বন্ধ"
+ },
+ "stateUnknown": {
+ "message": "অজানা"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray ডিস্ক থেকে খোলা পাতাগুলো পড়তে পারে।"
+ },
+ "accessOffNote": {
+ "message": "chrome://extensions খুলুন, Bento Tray খুঁজুন, “ফাইল URL-এ অ্যাক্সেসের অনুমতি দিন” চালু করুন।"
+ },
+ "accessUnknownNote": {
+ "message": "এই ব্রাউজার তা জানায় না। সংরক্ষণে এখনও জিজ্ঞাসা করা হলে chrome://extensions-এ দেখে নিন।"
+ },
+ "setVersionTitle": {
+ "message": "সংস্করণ"
+ },
+ "setVersionUnpacked": {
+ "message": "এই অনুলিপিটি আনপ্যাকড অবস্থায় লোড করা হয়েছিল, তাই Chrome একে কখনও আপডেট করবে না।"
+ },
+ "setVersionStore": {
+ "message": "স্টোর থেকে ইনস্টল করা, তাই এটি নিজেই আপডেট হয়।"
+ },
+ "versionAvailable": {
+ "message": "$1 পাওয়া যাচ্ছে"
+ },
+ "versionUpToDate": {
+ "message": "শেষ পরীক্ষার হিসেবে হালনাগাদ"
+ },
+ "versionManaged": {
+ "message": "ব্রাউজারই হালনাগাদ রাখে"
+ },
+ "getIt": {
+ "message": "নিন"
+ },
+ "checkNow": {
+ "message": "এখনই দেখুন"
+ },
+ "autoCheckPref": {
+ "message": "<b>ব্রাউজার চালু হলে নতুন সংস্করণ আছে কিনা দেখুন।</b><br>একটি স্থির ফাইলের জন্য bento.page-এ একটিমাত্র অনুরোধ। এটি কোনো শনাক্তকারী, সংস্করণ নম্বর বা আপনার নথি সম্পর্কে কিছুই পাঠায় না — তুলনাটি এখানেই হয়। বন্ধ করে দিলে কখনও কোনো অনুরোধ যাবে না; <b>এখনই দেখুন</b> তবু কাজ করবে।"
+ },
+ "expectedSha": {
+ "message": "zip-এর প্রত্যাশিত SHA-256: $1"
+ },
+ "setReachTitle": {
+ "message": "এটি কতদূর পৌঁছাতে পারে"
+ },
+ "setReachSub": {
+ "message": "কেবল উপরের ফোল্ডারগুলো, আর কেবল সেই ফাইল যেটি থেকে পাতাটি সত্যিই খোলা হয়েছিল। কিছুই আপলোড হয় না এবং অন্য কোথাও কিছুই পড়া হয় না।"
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 পাওয়া যাচ্ছে।</b> এই অনুলিপিটি আনপ্যাকড অবস্থায় লোড করা হয়েছিল, তাই Chrome একে কখনও আপডেট করবে না।"
+ },
+ "updateStep1": {
+ "message": "GitHub থেকে ডাউনলোড করুন"
+ },
+ "updateStep2": {
+ "message": "ফাইলগুলো <b>যে ফোল্ডার থেকে লোড করেছিলেন সেখানেই</b> বদলান — একই ফোল্ডার, নইলে Chrome একে আলাদা এক্সটেনশন ধরবে এবং অনুমতি পাওয়া ফোল্ডারগুলো সঙ্গে যাবে না"
+ },
+ "updateStep3": {
+ "message": "<code>chrome://extensions</code> খুলে Bento Tray-এ <b>পুনরায় লোড করুন</b> চাপুন"
+ },
+ "fetchingApp": {
+ "message": "$1 আনা হচ্ছে…"
+ },
+ "createdIn": {
+ "message": "$3-এ $1 ($2) তৈরি হয়েছে"
+ },
+ "intoFolder": {
+ "message": "$1-এ"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray কী করে"
+ },
+ "helpWhatSub": {
+ "message": "একটি Bento নথি হলো একটিমাত্র HTML ফাইল, যা নিজের সম্পাদক সঙ্গে নিয়ে চলে। সরাসরি ডিস্ক থেকে খুললে ব্রাউজার তাকে নিজের ভেতরে ফিরে লিখতে দেয় না — তাই প্রতিবার সংরক্ষণে জিজ্ঞাসা করা হয় কোথায় রাখবেন। Bento Tray সেই প্রশ্নটাই সরিয়ে দেয়।"
+ },
+ "tourSaveTitle": {
+ "message": "জায়গাতেই সংরক্ষণ"
+ },
+ "tourSaveBody": {
+ "message": "⌘S কোনো ডায়ালগ ছাড়াই সরাসরি সেই ফাইলে লেখে যেটি আপনি খুলেছিলেন। স্বয়ংক্রিয় সংরক্ষণ ও জায়গাতেই হওয়া আপডেটও একই পথে যায়।"
+ },
+ "tourFindTitle": {
+ "message": "আপনার নথি খুঁজুন"
+ },
+ "tourFindBody": {
+ "message": "আপনার ফোল্ডারের প্রতিটি Bento নথি, তার আসল শিরোনাম আর প্রথম পাতার ছবিসহ। খোঁজ নথির ভেতরে লেখা কথাও ছুঁয়ে যায়।"
+ },
+ "tourSwitchTitle": {
+ "message": "কাজ করতে করতে বদলান"
+ },
+ "tourSwitchBody": {
+ "message": "পাশে একটি প্যানেলের জন্য <kbd>Alt</kbd>+<kbd>B</kbd> চাপুন, কিংবা নথির ভেতরে ডান-ক্লিক করুন।"
+ },
+ "tourNewTitle": {
+ "message": "নতুন একটি বানান"
+ },
+ "tourNewBody": {
+ "message": "<b>+ নতুন নথি</b> Slides, Spaces বা Dash-এর বর্তমান রিলিজ এনে আপনার ফোল্ডারে একটি নতুন নথি রাখে।"
+ },
+ "helpNeedsTitle": {
+ "message": "আপনার কাছে এর যা দরকার"
+ },
+ "helpNeedsSub": {
+ "message": "দুটি জিনিস, দুটোই এই এক্সটেনশনের নিজে সামলানোর সাধ্যের বাইরে।"
+ },
+ "helpFolder": {
+ "message": "একটি ফোল্ডার"
+ },
+ "helpFolderGranted": {
+ "message": "$1টির অনুমতি আছে — এদের ভেতরের নথি জায়গাতেই সংরক্ষিত হয়"
+ },
+ "helpFolderNone": {
+ "message": "এখনও বাছা হয়নি। একটি বড় ফোল্ডার তার ভেতরের সবকিছু ধরে।"
+ },
+ "helpAccessOff": {
+ "message": "বন্ধ। <code>chrome://extensions</code>-এ <b>ফাইল URL-এ অ্যাক্সেসের অনুমতি দিন</b> চালু করুন — কোনো এক্সটেনশনই এটি নিজে চালু করতে পারে না।"
+ },
+ "helpAccessUnknown": {
+ "message": "এই ব্রাউজার তা জানায় না। সংরক্ষণে এখনও জিজ্ঞাসা করা হলে <code>chrome://extensions</code>-এ দেখে নিন।"
+ },
+ "helpAccessOn": {
+ "message": "চালু — Bento Tray ডিস্ক থেকে খোলা পাতাগুলো পড়তে পারে।"
+ },
+ "helpNeverTitle": {
+ "message": "এটি কখনও যা করে না"
+ },
+ "helpNeverSub": {
+ "message": "এটি কেবল উপরের ফোল্ডারগুলোর ভেতরে পড়ে ও লেখে, আর কেবল সেই ফাইলে যেটি থেকে পাতাটি সত্যিই খোলা হয়েছিল — কোনটি, তা ব্রাউজারই বলে দেয়, তাই কোনো নথি অন্য কারও ফাইলের নাম নিতে পারে না। আপনার নথি সম্পর্কে কিছুই কোথাও আপলোড হয় না, আর এক্সটেনশনটির আপলোড করার মতো কোনো সার্ভারই নেই।"
+ },
+ "helpAboutTitle": {
+ "message": "পরিচিতি"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · Bento প্রকল্পের অংশ · MIT লাইসেন্সপ্রাপ্ত"
+ },
+ "linkSource": {
+ "message": "GitHub-এ সোর্স"
+ },
+ "linkIssues": {
+ "message": "সমস্যার কথা জানান"
+ },
+ "linkReleases": {
+ "message": "রিলিজ"
+ },
+ "primeMiddle": {
+ "message": "যেটি টিকে থাকে"
+ },
+ "primeNote": {
+ "message": "বাকি দুটোও কাজ করে, তবে Chrome আবার জিজ্ঞাসা করে — প্রথমটির ক্ষেত্রে প্রতিবার পুনরায় চালুতে, আর শেষেরটির ক্ষেত্রে কিছুক্ষণ অপেক্ষার পর।"
+ }
+}
diff --git a/tray/webext/_locales/da/messages.json b/tray/webext/_locales/da/messages.json
new file mode 100644
index 00000000..97129386
--- /dev/null
+++ b/tray/webext/_locales/da/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Gem et Bento-dokument tilbage i den fil, du åbnede, uden at blive spurgt hvorhen."
+ },
+ "navAll": {
+ "message": "Alle dokumenter"
+ },
+ "navFolders": {
+ "message": "Mapper"
+ },
+ "navHelp": {
+ "message": "Hjælp og om"
+ },
+ "navSettings": {
+ "message": "Indstillinger"
+ },
+ "addFolder": {
+ "message": "+ Tilføj en mappe…"
+ },
+ "searchDocs": {
+ "message": "Søg i dokumenter"
+ },
+ "searchDocsSlash": {
+ "message": "Søg i dokumenter /"
+ },
+ "sortTitle": {
+ "message": "Sortér"
+ },
+ "sortRecent": {
+ "message": "Senest ændret"
+ },
+ "sortName": {
+ "message": "Navn"
+ },
+ "sortFolder": {
+ "message": "Mappe"
+ },
+ "newDocument": {
+ "message": "+ Nyt dokument"
+ },
+ "browseAll": {
+ "message": "Se alle"
+ },
+ "reconnectFolders": {
+ "message": "Forbind mapper igen"
+ },
+ "primeIntro": {
+ "message": "Chrome spørger om lidt. Vælg den midterste mulighed:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — en mappe skal forbindes igen"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray skal forbindes igen"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome har trukket tilladelsen til en mappe tilbage. Indtil den er genoprettet, spørger hver gemning, hvor filen skal ligge."
+ },
+ "reconnect": {
+ "message": "Forbind igen"
+ },
+ "ctxOpenPanel": {
+ "message": "Åbn Bento Tray-panelet"
+ },
+ "panelEmpty": {
+ "message": "Endnu ingen Bento-dokumenter i dine mapper."
+ },
+ "noMatches": {
+ "message": "Intet matcher “$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Åbn ét dokument i $1 én gang fra Finder, så kan alt i den mappe åbnes herfra."
+ },
+ "encrypted": {
+ "message": "Adgangskodebeskyttet"
+ },
+ "notSavedYet": {
+ "message": "Ikke gemt endnu"
+ },
+ "fileAccessOffShort": {
+ "message": "Adgang til lokale filer er slået fra"
+ },
+ "noFoldersYet": {
+ "message": "Ingen mapper endnu"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 mappe skal forbindes igen"
+ },
+ "statusOneFolder": {
+ "message": "$1 mappe · gemmer på stedet"
+ },
+ "statusFolders": {
+ "message": "$1 mapper · gemmer på stedet"
+ },
+ "renewNotOffered": {
+ "message": "Chrome tilbød ikke at genoprette den"
+ },
+ "renewTryAfterRestart": {
+ "message": "Prøv igen efter at have genstartet Chrome"
+ },
+ "fetchingLatest": {
+ "message": "Henter den nyeste Bento…"
+ },
+ "created": {
+ "message": "$1 oprettet"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 kan læses, men ikke åbnes endnu — Chrome fortæller ikke en udvidelse, hvor en mappe ligger på disken. <b>Se alle</b> finder dem med ét klik."
+ },
+ "andMore": {
+ "message": " og $1 mere"
+ },
+ "agoJustNow": {
+ "message": "lige nu"
+ },
+ "agoMinutes": {
+ "message": "for $1 min siden"
+ },
+ "agoHour": {
+ "message": "for $1 time siden"
+ },
+ "agoHours": {
+ "message": "for $1 timer siden"
+ },
+ "agoDay": {
+ "message": "for $1 dag siden"
+ },
+ "agoDays": {
+ "message": "for $1 dage siden"
+ },
+ "searchScope": {
+ "message": "Søgningen ser på titler, filnavne, mapper og ordene inde i dokumenterne."
+ },
+ "folderEmpty": {
+ "message": "Endnu intet i denne mappe"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Nyt dokument</b> lægger et friskt her."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray ved endnu ikke, hvor $1 ligger på disken. Brug “Find mine mapper”, eller åbn et dokument derfra i Finder én gang."
+ },
+ "cardRenamedTip": {
+ "message": "$1 er et Bento-dokument under et andet navn. Det åbner herfra, men gemning spørger om en placering — gemning på stedet genkender kun filer, der ender på .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Hedder .html i stedet for .bento.html — det åbner herfra, men gemning spørger om en placering."
+ },
+ "menuOpen": {
+ "message": "Åbn"
+ },
+ "menuDuplicate": {
+ "message": "Dublér"
+ },
+ "menuRename": {
+ "message": "Omdøb…"
+ },
+ "menuCopyPath": {
+ "message": "Kopiér sti"
+ },
+ "duplicatedAs": {
+ "message": "Dubleret som $1"
+ },
+ "renamePrompt": {
+ "message": "Omdøb dokument"
+ },
+ "renamedTo": {
+ "message": "Omdøbt til $1"
+ },
+ "pathCopied": {
+ "message": "Sti kopieret"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — ikke åbnet endnu"
+ },
+ "setupTitle": {
+ "message": "To ting, så er du klar"
+ },
+ "setupLead": {
+ "message": "Derefter skriver ⌘S i et dokument, du har åbnet med dobbeltklik, direkte tilbage til filen — aldrig mere spørgsmål om hvorhen."
+ },
+ "chooseFolder": {
+ "message": "Vælg en mappe…"
+ },
+ "setupStep1": {
+ "message": "Vælg den mappe, dine dokumenter ligger i"
+ },
+ "setupStep1Note": {
+ "message": "Én bred mappe er som regel nok — den dækker alt indeni."
+ },
+ "setupStep2": {
+ "message": "Slå adgang til lokale filer til"
+ },
+ "setupStep2Note": {
+ "message": "I <code>chrome://extensions</code> → Bento Tray → <b>Tillad adgang til fil-URL'er</b>. Chrome lader ikke en udvidelse slå dette til selv."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Opgraderet og forventede at finde dine mapper her?</b> En udpakket udvidelse identificeres ved sin mappesti, så en ny kopi indlæst fra en anden mappe er en anden udvidelse. Dine mapper hører stadig til den gamle. Udskift i stedet filerne i den oprindelige mappe og tryk <b>Genindlæs</b> i <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Adgang til lokale filer er slået fra</b> — intet gemmes på stedet, før den er slået til. Slå <b>Tillad adgang til fil-URL'er</b> til i <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 mappe skal forbindes igen.</b> Forbind den igen under <b>Indstillinger</b>, og vælg <b>Tillad ved hvert besøg</b> — den eneste mulighed, der varer ved."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> kan vises på listen, men ikke åbnes endnu — Chrome fortæller aldrig en udvidelse, hvor en mappe ligger på disken."
+ },
+ "findFolders": {
+ "message": "Find mine mapper"
+ },
+ "looking": {
+ "message": "Leder…"
+ },
+ "findDeclined": {
+ "message": "<b>Helt i orden.</b> Åbn i stedet et dokument i $1 fra Finder én gang — denne side opdager det."
+ },
+ "foundFolder": {
+ "message": "Fandt $1 mappe"
+ },
+ "foundFolders": {
+ "message": "Fandt $1 mapper"
+ },
+ "foundNothing": {
+ "message": "Endnu intet i historikken — åbn ét dokument fra Finder"
+ },
+ "setFoldersSub": {
+ "message": "Dokumenter heri gemmes direkte tilbage til filen uden at spørge hvorhen. En mappe dækker alt indeni."
+ },
+ "noneYet": {
+ "message": "Ingen endnu."
+ },
+ "savesInPlace": {
+ "message": "gemmer på stedet"
+ },
+ "needsReconnecting": {
+ "message": "skal forbindes igen"
+ },
+ "reconnectTip": {
+ "message": "Chrome vil spørge, om denne mappe må genoprettes. “Tillad ikke” dropper den, og derefter venter Chrome mindst en genstart, før den spørger igen."
+ },
+ "remove": {
+ "message": "Fjern"
+ },
+ "removeTip": {
+ "message": "Fjerner adgangen. Chrome kan stadig huske tilladelsen, så en mappe, der tilføjes igen, spørger måske ikke."
+ },
+ "setAccessTitle": {
+ "message": "Adgang til lokale filer"
+ },
+ "setAccessSub": {
+ "message": "Chrome lader ikke en udvidelse slå dette til selv, og intet virker uden."
+ },
+ "stateOn": {
+ "message": "Til"
+ },
+ "stateOff": {
+ "message": "Fra"
+ },
+ "stateUnknown": {
+ "message": "Ukendt"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray kan læse sider, du har åbnet fra disken."
+ },
+ "accessOffNote": {
+ "message": "Åbn chrome://extensions, find Bento Tray, og slå “Tillad adgang til fil-URL'er” til."
+ },
+ "accessUnknownNote": {
+ "message": "Denne browser oplyser det ikke. Hvis gemning stadig spørger, så tjek det i chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Version"
+ },
+ "setVersionUnpacked": {
+ "message": "Denne kopi blev indlæst udpakket, så Chrome opdaterer den aldrig."
+ },
+ "setVersionStore": {
+ "message": "Installeret fra butikken, så den opdaterer sig selv."
+ },
+ "versionAvailable": {
+ "message": "$1 er tilgængelig"
+ },
+ "versionUpToDate": {
+ "message": "opdateret ved seneste tjek"
+ },
+ "versionManaged": {
+ "message": "holdes opdateret af browseren"
+ },
+ "getIt": {
+ "message": "Hent den"
+ },
+ "checkNow": {
+ "message": "Tjek nu"
+ },
+ "autoCheckPref": {
+ "message": "<b>Tjek efter en ny version, når browseren starter.</b><br>Én forespørgsel til bento.page efter en statisk fil. Den sender ingen identifikatorer, intet versionsnummer og intet om dine dokumenter — sammenligningen sker her. Slå den fra, og der forespørges aldrig noget; <b>Tjek nu</b> virker stadig."
+ },
+ "expectedSha": {
+ "message": "Forventet SHA-256 for zip-filen: $1"
+ },
+ "setReachTitle": {
+ "message": "Hvad dette kan nå"
+ },
+ "setReachSub": {
+ "message": "Kun mapperne ovenfor, og kun den fil, en side faktisk blev åbnet fra. Intet uploades, og intet læses andre steder."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 er tilgængelig.</b> Denne kopi blev indlæst udpakket, så Chrome opdaterer den aldrig."
+ },
+ "updateStep1": {
+ "message": "Hent den fra GitHub"
+ },
+ "updateStep2": {
+ "message": "Udskift filerne <b>i den mappe, du indlæste den fra</b> — samme mappe, ellers behandler Chrome den som en anden udvidelse, og dine tilladte mapper følger ikke med"
+ },
+ "updateStep3": {
+ "message": "Åbn <code>chrome://extensions</code> og tryk <b>Genindlæs</b> på Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Henter $1…"
+ },
+ "createdIn": {
+ "message": "Oprettede $1 ($2) i $3"
+ },
+ "intoFolder": {
+ "message": "i $1"
+ },
+ "helpWhatTitle": {
+ "message": "Hvad Bento Tray gør"
+ },
+ "helpWhatSub": {
+ "message": "Et Bento-dokument er én HTML-fil, der bærer sin egen editor. Åbnet direkte fra disken vil en browser ikke lade den skrive tilbage til sig selv — så gemning spørger hver gang, hvor filen skal ligge. Bento Tray fjerner det spørgsmål."
+ },
+ "tourSaveTitle": {
+ "message": "Gem på stedet"
+ },
+ "tourSaveBody": {
+ "message": "⌘S skriver direkte tilbage til den fil, du åbnede, uden dialog. Automatisk gemning og opdateringer på stedet går samme vej."
+ },
+ "tourFindTitle": {
+ "message": "Find dine dokumenter"
+ },
+ "tourFindBody": {
+ "message": "Alle Bento-dokumenter i dine mapper med deres rigtige titel og et billede af første side. Søgningen dækker også det, der står inde i dem."
+ },
+ "tourSwitchTitle": {
+ "message": "Skift mens du arbejder"
+ },
+ "tourSwitchBody": {
+ "message": "Tryk <kbd>Alt</kbd>+<kbd>B</kbd>, eller højreklik inde i et dokument, for et panel ved siden af."
+ },
+ "tourNewTitle": {
+ "message": "Lav et nyt"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Nyt dokument</b> henter den aktuelle udgave af Slides, Spaces eller Dash og lægger et friskt dokument i din mappe."
+ },
+ "helpNeedsTitle": {
+ "message": "Hvad den har brug for fra dig"
+ },
+ "helpNeedsSub": {
+ "message": "To ting, som begge ligger uden for denne udvidelses magt at ordne."
+ },
+ "helpFolder": {
+ "message": "En mappe"
+ },
+ "helpFolderGranted": {
+ "message": "$1 tilladt — dokumenter deri gemmes på stedet"
+ },
+ "helpFolderNone": {
+ "message": "Ikke valgt endnu. Én bred mappe dækker alt indeni."
+ },
+ "helpAccessOff": {
+ "message": "Fra. Slå <b>Tillad adgang til fil-URL'er</b> til i <code>chrome://extensions</code> — ingen udvidelse kan slå dette til selv."
+ },
+ "helpAccessUnknown": {
+ "message": "Denne browser oplyser det ikke. Hvis gemning stadig spørger, så tjek det i <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Til — Bento Tray kan læse sider, du har åbnet fra disken."
+ },
+ "helpNeverTitle": {
+ "message": "Hvad den aldrig gør"
+ },
+ "helpNeverSub": {
+ "message": "Den læser og skriver kun inde i mapperne ovenfor, og kun den fil, en side faktisk blev åbnet fra — browseren fortæller hvilken, så et dokument kan ikke udpege en andens fil. Intet om dine dokumenter uploades nogen steder, og udvidelsen har ingen server at uploade dem til."
+ },
+ "helpAboutTitle": {
+ "message": "Om"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · del af Bento-projektet · MIT-licenseret"
+ },
+ "linkSource": {
+ "message": "Kildekode på GitHub"
+ },
+ "linkIssues": {
+ "message": "Rapportér et problem"
+ },
+ "linkReleases": {
+ "message": "Udgivelser"
+ },
+ "primeMiddle": {
+ "message": "den, der varer ved"
+ },
+ "primeNote": {
+ "message": "De to andre virker også, men Chrome spørger igen — ved hver genstart for den første, og efter en ventetid for den sidste."
+ }
+}
diff --git a/tray/webext/_locales/de/messages.json b/tray/webext/_locales/de/messages.json
new file mode 100644
index 00000000..723f070c
--- /dev/null
+++ b/tray/webext/_locales/de/messages.json
@@ -0,0 +1,446 @@
+{
+ "appDesc": {
+ "message": "Speichert ein Bento-Dokument zurück in die geöffnete Datei, ohne nach dem Ort zu fragen.",
+ "description": "Chrome Web Store listing description. 132 characters maximum — the store truncates."
+ },
+ "navAll": {
+ "message": "Alle Dokumente"
+ },
+ "navFolders": {
+ "message": "Ordner"
+ },
+ "navHelp": {
+ "message": "Hilfe & Über"
+ },
+ "navSettings": {
+ "message": "Einstellungen"
+ },
+ "addFolder": {
+ "message": "+ Ordner hinzufügen…"
+ },
+ "searchDocs": {
+ "message": "Dokumente durchsuchen"
+ },
+ "searchDocsSlash": {
+ "message": "Dokumente durchsuchen /"
+ },
+ "sortTitle": {
+ "message": "Sortieren"
+ },
+ "sortRecent": {
+ "message": "Zuletzt geändert"
+ },
+ "sortName": {
+ "message": "Name"
+ },
+ "sortFolder": {
+ "message": "Ordner"
+ },
+ "newDocument": {
+ "message": "+ Neues Dokument"
+ },
+ "browseAll": {
+ "message": "Alle anzeigen"
+ },
+ "reconnectFolders": {
+ "message": "Ordner neu verbinden"
+ },
+ "primeIntro": {
+ "message": "Chrome fragt als Nächstes. Wählen Sie die mittlere Option:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — ein Ordner muss neu verbunden werden",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray muss neu verbunden werden",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome hat die Berechtigung für einen Ordner entzogen. Bis sie wiederhergestellt ist, wird beim Speichern nach einem Ort gefragt.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnect": {
+ "message": "Neu verbinden"
+ },
+ "ctxOpenPanel": {
+ "message": "Bento-Tray-Leiste öffnen"
+ },
+ "panelEmpty": {
+ "message": "Noch keine Bento-Dokumente in Ihren Ordnern."
+ },
+ "noMatches": {
+ "message": "Nichts passt zu „$1“"
+ },
+ "rowUnplacedTip": {
+ "message": "Öffnen Sie einmal ein Dokument in $1 im Finder, dann lässt sich alles in diesem Ordner von hier öffnen."
+ },
+ "encrypted": {
+ "message": "Passwortgeschützt"
+ },
+ "notSavedYet": {
+ "message": "Noch nicht gespeichert"
+ },
+ "fileAccessOffShort": {
+ "message": "Zugriff auf lokale Dateien ist aus",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noFoldersYet": {
+ "message": "Noch keine Ordner"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 Ordner muss neu verbunden werden",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "statusOneFolder": {
+ "message": "$1 Ordner · speichert direkt"
+ },
+ "statusFolders": {
+ "message": "$1 Ordner · speichert direkt"
+ },
+ "renewNotOffered": {
+ "message": "Chrome hat die Wiederherstellung nicht angeboten",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "renewTryAfterRestart": {
+ "message": "Nach einem Neustart von Chrome erneut versuchen",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "fetchingLatest": {
+ "message": "Neuestes Bento wird geladen…"
+ },
+ "created": {
+ "message": "$1 erstellt"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 kann gelesen, aber noch nicht geöffnet werden — Chrome verrät einer Erweiterung nicht, wo ein Ordner auf der Festplatte liegt. <b>Alle anzeigen</b> findet sie mit einem Klick.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "andMore": {
+ "message": " und $1 weitere"
+ },
+ "agoJustNow": {
+ "message": "gerade eben"
+ },
+ "agoMinutes": {
+ "message": "vor $1 Min."
+ },
+ "agoHour": {
+ "message": "vor $1 Stunde"
+ },
+ "agoHours": {
+ "message": "vor $1 Stunden"
+ },
+ "agoDay": {
+ "message": "vor $1 Tag"
+ },
+ "agoDays": {
+ "message": "vor $1 Tagen"
+ },
+ "searchScope": {
+ "message": "Gesucht wird in Titeln, Dateinamen, Ordnern und im Text der Dokumente."
+ },
+ "folderEmpty": {
+ "message": "Noch nichts in diesem Ordner"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Neues Dokument</b> legt hier eines an."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray weiß noch nicht, wo $1 auf der Festplatte liegt. Nutzen Sie „Meine Ordner finden“ oder öffnen Sie einmal ein Dokument daraus im Finder.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "cardRenamedTip": {
+ "message": "$1 ist ein Bento-Dokument unter anderem Namen. Es lässt sich von hier öffnen, beim Speichern wird aber nach einem Ort gefragt — direktes Speichern erkennt nur Dateien auf .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Heißt .html statt .bento.html — lässt sich von hier öffnen, beim Speichern wird aber nach einem Ort gefragt."
+ },
+ "menuOpen": {
+ "message": "Öffnen"
+ },
+ "menuDuplicate": {
+ "message": "Duplizieren"
+ },
+ "menuRename": {
+ "message": "Umbenennen…"
+ },
+ "menuCopyPath": {
+ "message": "Pfad kopieren"
+ },
+ "duplicatedAs": {
+ "message": "Als $1 dupliziert"
+ },
+ "renamePrompt": {
+ "message": "Dokument umbenennen"
+ },
+ "renamedTo": {
+ "message": "In $1 umbenannt"
+ },
+ "pathCopied": {
+ "message": "Pfad kopiert"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — noch nicht geöffnet"
+ },
+ "setupTitle": {
+ "message": "Zwei Dinge, dann ist alles bereit"
+ },
+ "setupLead": {
+ "message": "Danach schreibt ⌘S bei einem per Doppelklick geöffneten Dokument direkt in die Datei zurück — nie wieder eine Frage nach dem Ort."
+ },
+ "chooseFolder": {
+ "message": "Ordner wählen…"
+ },
+ "setupStep1": {
+ "message": "Wählen Sie den Ordner, in dem Ihre Dokumente liegen"
+ },
+ "setupStep1Note": {
+ "message": "Ein großzügiger Ordner genügt meist — er deckt alles darin ab."
+ },
+ "setupStep2": {
+ "message": "Zugriff auf lokale Dateien einschalten",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupStep2Note": {
+ "message": "Unter <code>chrome://extensions</code> → Bento Tray → <b>Zugriff auf Datei-URLs zulassen</b>. Chrome lässt eine Erweiterung das nicht selbst einschalten.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Aktualisiert und Ihre Ordner fehlen?</b> Eine entpackte Erweiterung wird über ihren Ordnerpfad identifiziert; eine neue Kopie aus einem anderen Ordner ist deshalb eine andere Erweiterung. Ihre Ordner sind weiterhin für die alte freigegeben. Ersetzen Sie stattdessen die Dateien im ursprünglichen Ordner und drücken Sie unter <code>chrome://extensions</code> auf <b>Aktualisieren</b>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Zugriff auf lokale Dateien ist aus</b> — bis er an ist, wird nichts direkt gespeichert. Schalten Sie <b>Zugriff auf Datei-URLs zulassen</b> unter <code>chrome://extensions</code> ein.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 Ordner muss neu verbunden werden.</b> Verbinden Sie ihn in den <b>Einstellungen</b> neu und wählen Sie die mittlere Option — die einzige, die bleibt.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> kann aufgelistet, aber noch nicht geöffnet werden — Chrome verrät einer Erweiterung nie, wo ein Ordner auf der Festplatte liegt.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "findFolders": {
+ "message": "Meine Ordner finden"
+ },
+ "looking": {
+ "message": "Wird gesucht…"
+ },
+ "findDeclined": {
+ "message": "<b>Kein Problem.</b> Öffnen Sie stattdessen einmal ein Dokument in $1 im Finder — diese Seite bemerkt es."
+ },
+ "foundFolder": {
+ "message": "$1 Ordner gefunden"
+ },
+ "foundFolders": {
+ "message": "$1 Ordner gefunden"
+ },
+ "foundNothing": {
+ "message": "Noch nichts im Verlauf — öffnen Sie ein Dokument im Finder"
+ },
+ "setFoldersSub": {
+ "message": "Dokumente hierin speichern direkt zurück in die Datei, ohne Nachfrage nach dem Ort. Ein Ordner deckt alles darin ab."
+ },
+ "noneYet": {
+ "message": "Noch keine."
+ },
+ "savesInPlace": {
+ "message": "speichert direkt"
+ },
+ "needsReconnecting": {
+ "message": "muss neu verbunden werden",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnectTip": {
+ "message": "Chrome fragt, ob dieser Ordner wiederhergestellt werden soll. Ablehnen entfernt ihn, und Chrome wartet danach mindestens einen Neustart, bevor es erneut fragt.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "remove": {
+ "message": "Entfernen"
+ },
+ "removeTip": {
+ "message": "Entzieht den Zugriff. Chrome merkt sich die Berechtigung möglicherweise weiterhin, sodass beim erneuten Hinzufügen nicht noch einmal gefragt wird.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessTitle": {
+ "message": "Zugriff auf lokale Dateien",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessSub": {
+ "message": "Chrome lässt eine Erweiterung das nicht selbst einschalten, und ohne funktioniert nichts.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "stateOn": {
+ "message": "An"
+ },
+ "stateOff": {
+ "message": "Aus"
+ },
+ "stateUnknown": {
+ "message": "Unbekannt"
+ },
+ "setVersionTitle": {
+ "message": "Version"
+ },
+ "setVersionUnpacked": {
+ "message": "Diese Kopie wurde entpackt geladen, Chrome aktualisiert sie also nie."
+ },
+ "setVersionStore": {
+ "message": "Aus dem Store installiert, aktualisiert sich also selbst."
+ },
+ "versionAvailable": {
+ "message": "$1 ist verfügbar"
+ },
+ "versionUpToDate": {
+ "message": "aktuell laut letzter Prüfung"
+ },
+ "versionManaged": {
+ "message": "vom Browser aktuell gehalten"
+ },
+ "getIt": {
+ "message": "Holen"
+ },
+ "checkNow": {
+ "message": "Jetzt prüfen"
+ },
+ "autoCheckPref": {
+ "message": "<b>Beim Start des Browsers nach einer neuen Version suchen.</b><br>Eine Anfrage an bento.page nach einer statischen Datei. Sie sendet keine Kennungen, keine Versionsnummer und nichts über Ihre Dokumente — der Vergleich findet hier statt. Ausgeschaltet wird nie etwas angefragt; <b>Jetzt prüfen</b> funktioniert weiterhin.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "expectedSha": {
+ "message": "Erwarteter SHA-256 der ZIP-Datei: $1"
+ },
+ "setReachTitle": {
+ "message": "Worauf dies zugreifen kann",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setReachSub": {
+ "message": "Nur die Ordner oben und nur die Datei, aus der eine Seite tatsächlich geöffnet wurde. Nichts wird hochgeladen und nichts anderswo gelesen.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 ist verfügbar.</b> Diese Kopie wurde entpackt geladen, Chrome aktualisiert sie also nie."
+ },
+ "updateStep1": {
+ "message": "Von GitHub herunterladen"
+ },
+ "updateStep2": {
+ "message": "Ersetzen Sie die Dateien <b>in dem Ordner, aus dem Sie sie geladen haben</b> — derselbe Ordner, sonst behandelt Chrome sie als andere Erweiterung und Ihre freigegebenen Ordner kommen nicht mit",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateStep3": {
+ "message": "Öffnen Sie <code>chrome://extensions</code> und drücken Sie bei Bento Tray auf <b>Aktualisieren</b>"
+ },
+ "fetchingApp": {
+ "message": "$1 wird geladen…"
+ },
+ "createdIn": {
+ "message": "$1 ($2) in $3 erstellt"
+ },
+ "intoFolder": {
+ "message": "nach $1"
+ },
+ "helpWhatTitle": {
+ "message": "Was Bento Tray tut"
+ },
+ "helpWhatSub": {
+ "message": "Ein Bento-Dokument ist eine HTML-Datei, die ihren eigenen Editor mitbringt. Direkt von der Festplatte geöffnet, lässt ein Browser sie nicht in sich selbst zurückschreiben — beim Speichern wird also jedes Mal nach einem Ort gefragt. Bento Tray nimmt diese Frage weg."
+ },
+ "tourSaveTitle": {
+ "message": "Direkt speichern"
+ },
+ "tourSaveBody": {
+ "message": "⌘S schreibt ohne Dialog direkt in die geöffnete Datei zurück. Automatisches Speichern und Updates gehen denselben Weg."
+ },
+ "tourFindTitle": {
+ "message": "Ihre Dokumente finden"
+ },
+ "tourFindBody": {
+ "message": "Jedes Bento-Dokument in Ihren Ordnern, mit echtem Titel und einem Bild der ersten Seite. Die Suche erfasst auch den Text darin."
+ },
+ "tourSwitchTitle": {
+ "message": "Wechseln während der Arbeit"
+ },
+ "tourSwitchBody": {
+ "message": "Drücken Sie <kbd>Alt</kbd>+<kbd>B</kbd> oder klicken Sie mit der rechten Maustaste in ein Dokument, für eine Leiste daneben."
+ },
+ "tourNewTitle": {
+ "message": "Ein neues anlegen"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Neues Dokument</b> lädt die aktuelle Version von Slides, Spaces oder Dash und legt ein frisches Dokument in Ihrem Ordner an."
+ },
+ "helpNeedsTitle": {
+ "message": "Was es von Ihnen braucht"
+ },
+ "helpNeedsSub": {
+ "message": "Zwei Dinge, beide außerhalb der Macht dieser Erweiterung."
+ },
+ "helpFolder": {
+ "message": "Ein Ordner"
+ },
+ "helpFolderGranted": {
+ "message": "$1 freigegeben — Dokumente darin speichern direkt"
+ },
+ "helpFolderNone": {
+ "message": "Noch nicht gewählt. Ein großzügiger Ordner deckt alles darin ab."
+ },
+ "helpAccessOff": {
+ "message": "Aus. Schalten Sie <b>Zugriff auf Datei-URLs zulassen</b> unter <code>chrome://extensions</code> ein — keine Erweiterung kann das für sich selbst tun.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessUnknown": {
+ "message": "Dieser Browser meldet es nicht. Wird beim Speichern weiterhin gefragt, prüfen Sie es unter <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessOn": {
+ "message": "An — Bento Tray kann Seiten lesen, die Sie von der Festplatte geöffnet haben.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverTitle": {
+ "message": "Was es nie tut",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverSub": {
+ "message": "Es liest und schreibt nur in den Ordnern oben und nur die Datei, aus der eine Seite tatsächlich geöffnet wurde — der Browser sagt, welche das ist, sodass ein Dokument nicht die Datei eines anderen benennen kann. Nichts über Ihre Dokumente wird irgendwohin hochgeladen, und die Erweiterung hat auch keinen Server dafür.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAboutTitle": {
+ "message": "Über"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · Teil des Bento-Projekts · MIT-Lizenz"
+ },
+ "linkSource": {
+ "message": "Quellcode auf GitHub"
+ },
+ "linkIssues": {
+ "message": "Problem melden"
+ },
+ "linkReleases": {
+ "message": "Versionen"
+ },
+ "primeMiddle": {
+ "message": "die, die bleibt"
+ },
+ "primeNote": {
+ "message": "Die anderen beiden funktionieren auch, aber Chrome fragt erneut — bei der ersten nach jedem Neustart, bei der letzten nach einer Wartezeit."
+ },
+ "accessOnNote": {
+ "message": "Bento Tray kann Seiten lesen, die Sie von der Festplatte geöffnet haben.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessOffNote": {
+ "message": "Öffnen Sie chrome://extensions, suchen Sie Bento Tray und schalten Sie „Zugriff auf Datei-URLs zulassen“ ein.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessUnknownNote": {
+ "message": "Dieser Browser meldet es nicht. Wird beim Speichern weiterhin gefragt, prüfen Sie es unter chrome://extensions.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ }
+}
diff --git a/tray/webext/_locales/en/messages.json b/tray/webext/_locales/en/messages.json
new file mode 100644
index 00000000..386b36e4
--- /dev/null
+++ b/tray/webext/_locales/en/messages.json
@@ -0,0 +1,456 @@
+{
+ "appName": {
+ "message": "Bento Tray",
+ "description": "Product name. Not translated."
+ },
+ "appDesc": {
+ "message": "Save a Bento document back to the file you opened, without a destination prompt.",
+ "description": "Chrome Web Store listing description. 132 characters maximum — the store truncates."
+ },
+ "navAll": {
+ "message": "All documents"
+ },
+ "navFolders": {
+ "message": "Folders"
+ },
+ "navHelp": {
+ "message": "Help & about"
+ },
+ "navSettings": {
+ "message": "Settings"
+ },
+ "addFolder": {
+ "message": "+ Add a folder…"
+ },
+ "searchDocs": {
+ "message": "Search documents"
+ },
+ "searchDocsSlash": {
+ "message": "Search documents /",
+ "description": "The slash hints at the / keyboard shortcut."
+ },
+ "sortTitle": {
+ "message": "Sort"
+ },
+ "sortRecent": {
+ "message": "Recently changed"
+ },
+ "sortName": {
+ "message": "Name"
+ },
+ "sortFolder": {
+ "message": "Folder"
+ },
+ "newDocument": {
+ "message": "+ New document"
+ },
+ "browseAll": {
+ "message": "Browse all"
+ },
+ "reconnectFolders": {
+ "message": "Reconnect folders"
+ },
+ "primeIntro": {
+ "message": "Chrome will ask next. Pick the middle option:",
+ "description": "Above a drawing of Chrome’s three-option dialog. Deliberately says POSITION, not Chrome’s button names — the order is the same in every language, the wording is not."
+ },
+ "actionTitle": {
+ "message": "Bento Tray",
+ "description": "Tooltip on the toolbar icon."
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — a folder needs reconnecting",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray needs reconnecting",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome dropped permission for a folder. Until it is restored, saving a document will ask you where to put it.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnect": {
+ "message": "Reconnect"
+ },
+ "ctxOpenPanel": {
+ "message": "Open Bento Tray panel",
+ "description": "Right-click menu item inside a local document."
+ },
+ "panelEmpty": {
+ "message": "No Bento documents in your folders yet."
+ },
+ "noMatches": {
+ "message": "Nothing matches “$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Open any document in $1 once from Finder, and everything in that folder becomes openable from here."
+ },
+ "encrypted": {
+ "message": "Password-protected"
+ },
+ "notSavedYet": {
+ "message": "Not saved yet"
+ },
+ "fileAccessOffShort": {
+ "message": "Local file access is off",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noFoldersYet": {
+ "message": "No folders yet"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 folder needs reconnecting",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "statusOneFolder": {
+ "message": "$1 folder · saves in place"
+ },
+ "statusFolders": {
+ "message": "$1 folders · saves in place"
+ },
+ "renewNotOffered": {
+ "message": "Chrome did not offer to restore it",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "renewTryAfterRestart": {
+ "message": "Try again after restarting Chrome",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "fetchingLatest": {
+ "message": "Fetching the latest Bento…"
+ },
+ "created": {
+ "message": "Created $1"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 can be read but not opened yet — Chrome does not tell an extension where a folder is on disk. <b>Browse all</b> can find them in one click.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "andMore": {
+ "message": " and $1 more"
+ },
+ "agoJustNow": {
+ "message": "just now"
+ },
+ "agoMinutes": {
+ "message": "$1 min ago"
+ },
+ "agoHour": {
+ "message": "$1 hour ago"
+ },
+ "agoHours": {
+ "message": "$1 hours ago"
+ },
+ "agoDay": {
+ "message": "$1 day ago"
+ },
+ "agoDays": {
+ "message": "$1 days ago"
+ },
+ "searchScope": {
+ "message": "Search looks at titles, file names, folders and the words inside documents."
+ },
+ "folderEmpty": {
+ "message": "Nothing in this folder yet"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ New document</b> puts a fresh one here."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray does not know where $1 is on disk yet. Use “Find my folders”, or open any document in it from Finder once.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "cardRenamedTip": {
+ "message": "$1 is a Bento document under another name. It opens from here, but saving will ask for a destination — in-place saving only recognises files ending .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Named .html rather than .bento.html — it opens from here, but saving will ask for a destination."
+ },
+ "menuOpen": {
+ "message": "Open"
+ },
+ "menuDuplicate": {
+ "message": "Duplicate"
+ },
+ "menuRename": {
+ "message": "Rename…"
+ },
+ "menuCopyPath": {
+ "message": "Copy path"
+ },
+ "duplicatedAs": {
+ "message": "Duplicated as $1"
+ },
+ "renamePrompt": {
+ "message": "Rename document"
+ },
+ "renamedTo": {
+ "message": "Renamed to $1"
+ },
+ "pathCopied": {
+ "message": "Path copied"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — not opened yet"
+ },
+ "setupTitle": {
+ "message": "Two things and you are set up"
+ },
+ "setupLead": {
+ "message": "After this, ⌘S on a document you opened by double-clicking writes straight back to the file — no destination prompt, ever."
+ },
+ "chooseFolder": {
+ "message": "Choose a folder…"
+ },
+ "setupStep1": {
+ "message": "Choose the folder your documents live in"
+ },
+ "setupStep1Note": {
+ "message": "One broad folder is usually enough — it covers everything inside it."
+ },
+ "setupStep2": {
+ "message": "Turn on local file access",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupStep2Note": {
+ "message": "In <code>chrome://extensions</code> → Bento Tray → <b>Allow access to file URLs</b>. Chrome does not let an extension turn this on for itself.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Upgrading and expected your folders to be here?</b> An unpacked extension is identified by its folder path, so loading a new copy from a different folder makes it a different extension. Your folders are still granted to the old one. Replace the files in the original folder and press <b>Reload</b> in <code>chrome://extensions</code> instead.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Local file access is off</b> — nothing saves in place until it is on. Turn on <b>Allow access to file URLs</b> in <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 folder needs reconnecting.</b> Reconnect it in <b>Settings</b>, and choose <b>Allow on every visit</b> — the only option that lasts.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> can be listed but not opened yet — Chrome never tells an extension where a folder is on disk.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "findFolders": {
+ "message": "Find my folders"
+ },
+ "looking": {
+ "message": "Looking…"
+ },
+ "findDeclined": {
+ "message": "<b>No problem.</b> Open any document in $1 from Finder once instead — this page notices."
+ },
+ "foundFolder": {
+ "message": "Found $1 folder"
+ },
+ "foundFolders": {
+ "message": "Found $1 folders"
+ },
+ "foundNothing": {
+ "message": "Nothing in history yet — open one document from Finder"
+ },
+ "setFoldersSub": {
+ "message": "Documents in these save straight back to the file, with no destination prompt. A folder covers everything inside it."
+ },
+ "noneYet": {
+ "message": "None yet."
+ },
+ "savesInPlace": {
+ "message": "saves in place"
+ },
+ "needsReconnecting": {
+ "message": "needs reconnecting",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnectTip": {
+ "message": "Chrome will ask to restore this folder. “Don’t allow” drops it, and Chrome then waits a restart or more before offering again.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "remove": {
+ "message": "Remove"
+ },
+ "removeTip": {
+ "message": "Takes access away. Chrome may still remember the permission, so adding the folder back may not ask again.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessTitle": {
+ "message": "Local file access",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessSub": {
+ "message": "Chrome will not let an extension turn this on for itself, and nothing works without it.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "stateOn": {
+ "message": "On"
+ },
+ "stateOff": {
+ "message": "Off"
+ },
+ "stateUnknown": {
+ "message": "Unknown"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray can read pages you opened from disk.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessOffNote": {
+ "message": "Open chrome://extensions, find Bento Tray, turn on “Allow access to file URLs”.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessUnknownNote": {
+ "message": "This browser will not report it. If saves still prompt, check it in chrome://extensions.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setVersionTitle": {
+ "message": "Version"
+ },
+ "setVersionUnpacked": {
+ "message": "This copy was loaded unpacked, so Chrome will never update it."
+ },
+ "setVersionStore": {
+ "message": "Installed from the store, so it updates itself."
+ },
+ "versionAvailable": {
+ "message": "$1 is available"
+ },
+ "versionUpToDate": {
+ "message": "up to date as of the last check"
+ },
+ "versionManaged": {
+ "message": "kept current by the browser"
+ },
+ "getIt": {
+ "message": "Get it"
+ },
+ "checkNow": {
+ "message": "Check now"
+ },
+ "autoCheckPref": {
+ "message": "<b>Check for a new version when the browser starts.</b><br>One request to bento.page for a static file. It sends no identifiers, no version number and nothing about your documents — the comparison happens here. Turn it off and nothing is ever requested; <b>Check now</b> still works.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "expectedSha": {
+ "message": "Expected SHA-256 of the zip: $1"
+ },
+ "setReachTitle": {
+ "message": "What this can reach",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setReachSub": {
+ "message": "Only the folders above, and only the file a page was actually opened from. Nothing is uploaded and nothing is read anywhere else.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 is available.</b> This copy was loaded unpacked, so Chrome will never update it."
+ },
+ "updateStep1": {
+ "message": "Download it from GitHub"
+ },
+ "updateStep2": {
+ "message": "Replace the files <b>in the folder you loaded it from</b> — same folder, or Chrome treats it as a different extension and your granted folders do not come with it",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateStep3": {
+ "message": "Open <code>chrome://extensions</code> and press <b>Reload</b> on Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Fetching $1…"
+ },
+ "createdIn": {
+ "message": "Created $1 ($2) in $3"
+ },
+ "intoFolder": {
+ "message": "into $1"
+ },
+ "helpWhatTitle": {
+ "message": "What Bento Tray does"
+ },
+ "helpWhatSub": {
+ "message": "A Bento document is one HTML file that carries its own editor. Opened straight from disk, a browser will not let it write back to itself — so saving asks you where to put it, every time. Bento Tray is what removes that question."
+ },
+ "tourSaveTitle": {
+ "message": "Save in place"
+ },
+ "tourSaveBody": {
+ "message": "⌘S writes straight back to the file you opened, with no dialog. Autosave and in-place updates go the same way."
+ },
+ "tourFindTitle": {
+ "message": "Find your documents"
+ },
+ "tourFindBody": {
+ "message": "Every Bento document in your folders, with its real title and a picture of its first page. Search covers what is written inside them."
+ },
+ "tourSwitchTitle": {
+ "message": "Switch while you work"
+ },
+ "tourSwitchBody": {
+ "message": "Press <kbd>Alt</kbd>+<kbd>B</kbd>, or right-click inside a document, for a panel beside it."
+ },
+ "tourNewTitle": {
+ "message": "Make a new one"
+ },
+ "tourNewBody": {
+ "message": "<b>+ New document</b> fetches the current release of Slides, Spaces or Dash and puts a fresh document in your folder."
+ },
+ "helpNeedsTitle": {
+ "message": "What it needs from you"
+ },
+ "helpNeedsSub": {
+ "message": "Two things, both outside this extension’s power to arrange."
+ },
+ "helpFolder": {
+ "message": "A folder"
+ },
+ "helpFolderGranted": {
+ "message": "$1 granted — documents inside them save in place"
+ },
+ "helpFolderNone": {
+ "message": "Not chosen yet. One broad folder covers everything inside it."
+ },
+ "helpAccessOff": {
+ "message": "Off. Turn on <b>Allow access to file URLs</b> in <code>chrome://extensions</code> — no extension can turn this on for itself.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessUnknown": {
+ "message": "This browser will not report it. If saves still prompt, check it in <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessOn": {
+ "message": "On — Bento Tray can read pages you opened from disk.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverTitle": {
+ "message": "What it never does",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverSub": {
+ "message": "It reads and writes only inside the folders above, and only the file a page was actually opened from — the browser tells it which, so a document cannot name somebody else’s file. Nothing about your documents is uploaded anywhere, and the extension has no server to upload them to.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAboutTitle": {
+ "message": "About"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · part of the Bento project · MIT licensed"
+ },
+ "linkSource": {
+ "message": "Source on GitHub"
+ },
+ "linkIssues": {
+ "message": "Report a problem"
+ },
+ "linkReleases": {
+ "message": "Releases"
+ },
+ "primeMiddle": {
+ "message": "the one that lasts",
+ "description": "Label on the highlighted middle pill. Describes what the option DOES; do not substitute Chrome’s own button text, which cannot be verified per language."
+ },
+ "primeNote": {
+ "message": "The other two work too, but Chrome asks again — every restart for the first, and after a wait for the last.",
+ "description": "Explains the two unlabelled pills by consequence rather than by name."
+ }
+}
diff --git a/tray/webext/_locales/es/messages.json b/tray/webext/_locales/es/messages.json
new file mode 100644
index 00000000..44dd41e4
--- /dev/null
+++ b/tray/webext/_locales/es/messages.json
@@ -0,0 +1,446 @@
+{
+ "appDesc": {
+ "message": "Guarda un documento de Bento en el archivo que abriste, sin preguntar dónde.",
+ "description": "Chrome Web Store listing description. 132 characters maximum — the store truncates."
+ },
+ "navAll": {
+ "message": "Todos los documentos"
+ },
+ "navFolders": {
+ "message": "Carpetas"
+ },
+ "navHelp": {
+ "message": "Ayuda y acerca de"
+ },
+ "navSettings": {
+ "message": "Ajustes"
+ },
+ "addFolder": {
+ "message": "+ Añadir una carpeta…"
+ },
+ "searchDocs": {
+ "message": "Buscar documentos"
+ },
+ "searchDocsSlash": {
+ "message": "Buscar documentos /"
+ },
+ "sortTitle": {
+ "message": "Ordenar"
+ },
+ "sortRecent": {
+ "message": "Modificados recientemente"
+ },
+ "sortName": {
+ "message": "Nombre"
+ },
+ "sortFolder": {
+ "message": "Carpeta"
+ },
+ "newDocument": {
+ "message": "+ Nuevo documento"
+ },
+ "browseAll": {
+ "message": "Ver todos"
+ },
+ "reconnectFolders": {
+ "message": "Reconectar carpetas"
+ },
+ "primeIntro": {
+ "message": "Chrome preguntará ahora. Elige la opción del medio:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — una carpeta necesita reconectarse",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray necesita reconectarse",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome retiró el permiso de una carpeta. Hasta que se restaure, al guardar un documento se preguntará dónde ponerlo.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnect": {
+ "message": "Reconectar"
+ },
+ "ctxOpenPanel": {
+ "message": "Abrir el panel de Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "Aún no hay documentos de Bento en tus carpetas."
+ },
+ "noMatches": {
+ "message": "Nada coincide con «$1»"
+ },
+ "rowUnplacedTip": {
+ "message": "Abre una vez un documento de $1 desde el Finder y todo lo de esa carpeta se podrá abrir desde aquí."
+ },
+ "encrypted": {
+ "message": "Protegido con contraseña"
+ },
+ "notSavedYet": {
+ "message": "Aún sin guardar"
+ },
+ "fileAccessOffShort": {
+ "message": "El acceso a archivos locales está desactivado",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noFoldersYet": {
+ "message": "Aún no hay carpetas"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 carpeta necesita reconectarse",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "statusOneFolder": {
+ "message": "$1 carpeta · guarda en el sitio"
+ },
+ "statusFolders": {
+ "message": "$1 carpetas · guarda en el sitio"
+ },
+ "renewNotOffered": {
+ "message": "Chrome no ofreció restaurarla",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "renewTryAfterRestart": {
+ "message": "Inténtalo de nuevo tras reiniciar Chrome",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "fetchingLatest": {
+ "message": "Descargando el Bento más reciente…"
+ },
+ "created": {
+ "message": "$1 creado"
+ },
+ "panelUnplaced": {
+ "message": "Se puede leer <b>$1</b>$2, pero aún no abrirlo: Chrome no le dice a una extensión dónde está una carpeta en el disco. <b>Ver todos</b> los encuentra con un clic.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "andMore": {
+ "message": " y $1 más"
+ },
+ "agoJustNow": {
+ "message": "ahora mismo"
+ },
+ "agoMinutes": {
+ "message": "hace $1 min"
+ },
+ "agoHour": {
+ "message": "hace $1 hora"
+ },
+ "agoHours": {
+ "message": "hace $1 horas"
+ },
+ "agoDay": {
+ "message": "hace $1 día"
+ },
+ "agoDays": {
+ "message": "hace $1 días"
+ },
+ "searchScope": {
+ "message": "La búsqueda mira títulos, nombres de archivo, carpetas y el texto dentro de los documentos."
+ },
+ "folderEmpty": {
+ "message": "Aún no hay nada en esta carpeta"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Nuevo documento</b> pone uno aquí."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray todavía no sabe dónde está $1 en el disco. Usa «Encontrar mis carpetas» o abre una vez un documento suyo desde el Finder.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "cardRenamedTip": {
+ "message": "$1 es un documento de Bento con otro nombre. Se abre desde aquí, pero al guardar preguntará dónde — guardar en el sitio solo reconoce archivos terminados en .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Se llama .html en vez de .bento.html — se abre desde aquí, pero al guardar preguntará dónde."
+ },
+ "menuOpen": {
+ "message": "Abrir"
+ },
+ "menuDuplicate": {
+ "message": "Duplicar"
+ },
+ "menuRename": {
+ "message": "Cambiar nombre…"
+ },
+ "menuCopyPath": {
+ "message": "Copiar ruta"
+ },
+ "duplicatedAs": {
+ "message": "Duplicado como $1"
+ },
+ "renamePrompt": {
+ "message": "Cambiar el nombre del documento"
+ },
+ "renamedTo": {
+ "message": "Renombrado a $1"
+ },
+ "pathCopied": {
+ "message": "Ruta copiada"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — aún sin abrir"
+ },
+ "setupTitle": {
+ "message": "Dos cosas y ya está"
+ },
+ "setupLead": {
+ "message": "Después de esto, ⌘S en un documento abierto con doble clic escribe directamente en el archivo — sin preguntar dónde, nunca."
+ },
+ "chooseFolder": {
+ "message": "Elegir una carpeta…"
+ },
+ "setupStep1": {
+ "message": "Elige la carpeta donde viven tus documentos"
+ },
+ "setupStep1Note": {
+ "message": "Una carpeta amplia suele bastar — cubre todo lo que hay dentro."
+ },
+ "setupStep2": {
+ "message": "Activa el acceso a archivos locales",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupStep2Note": {
+ "message": "En <code>chrome://extensions</code> → Bento Tray → <b>Permitir acceso a URL de archivo</b>. Chrome no deja que una extensión lo active por sí misma.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>¿Actualizaste y esperabas ver tus carpetas?</b> Una extensión descomprimida se identifica por la ruta de su carpeta, así que cargar una copia nueva desde otra carpeta la convierte en otra extensión. Tus carpetas siguen concedidas a la anterior. Sustituye los archivos en la carpeta original y pulsa <b>Actualizar</b> en <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>El acceso a archivos locales está desactivado</b> — hasta que se active, nada se guarda en el sitio. Activa <b>Permitir acceso a URL de archivo</b> en <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 carpeta necesita reconectarse.</b> Reconéctala en <b>Ajustes</b> y elige la opción del medio — la única que dura.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> se puede listar pero aún no abrir — Chrome nunca le dice a una extensión dónde está una carpeta en el disco.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "findFolders": {
+ "message": "Encontrar mis carpetas"
+ },
+ "looking": {
+ "message": "Buscando…"
+ },
+ "findDeclined": {
+ "message": "<b>Sin problema.</b> Abre una vez un documento de $1 desde el Finder — esta página se dará cuenta."
+ },
+ "foundFolder": {
+ "message": "$1 carpeta encontrada"
+ },
+ "foundFolders": {
+ "message": "$1 carpetas encontradas"
+ },
+ "foundNothing": {
+ "message": "Nada en el historial todavía — abre un documento desde el Finder"
+ },
+ "setFoldersSub": {
+ "message": "Los documentos que están aquí se guardan directamente en su archivo, sin preguntar dónde. Una carpeta cubre todo lo que hay dentro."
+ },
+ "noneYet": {
+ "message": "Ninguna todavía."
+ },
+ "savesInPlace": {
+ "message": "guarda en el sitio"
+ },
+ "needsReconnecting": {
+ "message": "necesita reconectarse",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnectTip": {
+ "message": "Chrome pedirá restaurar esta carpeta. Rechazarlo la quita, y después Chrome espera al menos un reinicio antes de volver a ofrecerlo.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "remove": {
+ "message": "Quitar"
+ },
+ "removeTip": {
+ "message": "Retira el acceso. Chrome puede seguir recordando el permiso, así que volver a añadir la carpeta quizá no vuelva a preguntar.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessTitle": {
+ "message": "Acceso a archivos locales",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessSub": {
+ "message": "Chrome no deja que una extensión active esto por sí misma, y sin ello nada funciona.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "stateOn": {
+ "message": "Activado"
+ },
+ "stateOff": {
+ "message": "Desactivado"
+ },
+ "stateUnknown": {
+ "message": "Desconocido"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray puede leer las páginas que abriste desde el disco.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessOffNote": {
+ "message": "Abre chrome://extensions, busca Bento Tray y activa «Permitir acceso a URL de archivo».",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessUnknownNote": {
+ "message": "Este navegador no lo indica. Si al guardar sigue preguntando, compruébalo en chrome://extensions.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setVersionTitle": {
+ "message": "Versión"
+ },
+ "setVersionUnpacked": {
+ "message": "Esta copia se cargó descomprimida, así que Chrome nunca la actualizará."
+ },
+ "setVersionStore": {
+ "message": "Instalado desde la tienda, así que se actualiza solo."
+ },
+ "versionAvailable": {
+ "message": "$1 está disponible"
+ },
+ "versionUpToDate": {
+ "message": "al día según la última comprobación"
+ },
+ "versionManaged": {
+ "message": "lo mantiene al día el navegador"
+ },
+ "getIt": {
+ "message": "Obtener"
+ },
+ "checkNow": {
+ "message": "Comprobar ahora"
+ },
+ "autoCheckPref": {
+ "message": "<b>Buscar una versión nueva al iniciar el navegador.</b><br>Una petición a bento.page de un archivo estático. No envía identificadores, ni el número de versión, ni nada sobre tus documentos — la comparación se hace aquí. Desactivado no se pide nada nunca; <b>Comprobar ahora</b> sigue funcionando.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "expectedSha": {
+ "message": "SHA-256 esperado del zip: $1"
+ },
+ "setReachTitle": {
+ "message": "A qué puede llegar",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setReachSub": {
+ "message": "Solo las carpetas de arriba, y solo el archivo desde el que se abrió una página. Nada se sube y nada se lee en ningún otro sitio.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 está disponible.</b> Esta copia se cargó descomprimida, así que Chrome nunca la actualizará."
+ },
+ "updateStep1": {
+ "message": "Descárgalo de GitHub"
+ },
+ "updateStep2": {
+ "message": "Sustituye los archivos <b>en la carpeta desde la que lo cargaste</b> — la misma carpeta, o Chrome lo tratará como otra extensión y tus carpetas concedidas no vendrán con él",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateStep3": {
+ "message": "Abre <code>chrome://extensions</code> y pulsa <b>Actualizar</b> en Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Descargando $1…"
+ },
+ "createdIn": {
+ "message": "$1 ($2) creado en $3"
+ },
+ "intoFolder": {
+ "message": "en $1"
+ },
+ "helpWhatTitle": {
+ "message": "Qué hace Bento Tray"
+ },
+ "helpWhatSub": {
+ "message": "Un documento de Bento es un archivo HTML que lleva su propio editor. Abierto directamente desde el disco, el navegador no le deja escribir sobre sí mismo — así que al guardar pregunta dónde ponerlo, cada vez. Bento Tray es lo que quita esa pregunta."
+ },
+ "tourSaveTitle": {
+ "message": "Guarda en el sitio"
+ },
+ "tourSaveBody": {
+ "message": "⌘S escribe directamente en el archivo que abriste, sin diálogo. El guardado automático y las actualizaciones van por el mismo camino."
+ },
+ "tourFindTitle": {
+ "message": "Encuentra tus documentos"
+ },
+ "tourFindBody": {
+ "message": "Todos los documentos de Bento de tus carpetas, con su título real y una imagen de su primera página. La búsqueda cubre lo que está escrito dentro."
+ },
+ "tourSwitchTitle": {
+ "message": "Cambia mientras trabajas"
+ },
+ "tourSwitchBody": {
+ "message": "Pulsa <kbd>Alt</kbd>+<kbd>B</kbd>, o haz clic derecho dentro de un documento, para tener un panel al lado."
+ },
+ "tourNewTitle": {
+ "message": "Crea uno nuevo"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Nuevo documento</b> descarga la versión actual de Slides, Spaces o Dash y pone un documento nuevo en tu carpeta."
+ },
+ "helpNeedsTitle": {
+ "message": "Lo que necesita de ti"
+ },
+ "helpNeedsSub": {
+ "message": "Dos cosas, ambas fuera del alcance de esta extensión."
+ },
+ "helpFolder": {
+ "message": "Una carpeta"
+ },
+ "helpFolderGranted": {
+ "message": "$1 concedidas — los documentos dentro se guardan en el sitio"
+ },
+ "helpFolderNone": {
+ "message": "Aún sin elegir. Una carpeta amplia cubre todo lo que hay dentro."
+ },
+ "helpAccessOff": {
+ "message": "Desactivado. Activa <b>Permitir acceso a URL de archivo</b> en <code>chrome://extensions</code> — ninguna extensión puede activarlo por sí misma.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessUnknown": {
+ "message": "Este navegador no lo indica. Si al guardar sigue preguntando, compruébalo en <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessOn": {
+ "message": "Activado — Bento Tray puede leer las páginas que abriste desde el disco.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverTitle": {
+ "message": "Lo que nunca hace",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverSub": {
+ "message": "Lee y escribe solo dentro de las carpetas de arriba, y solo el archivo desde el que se abrió una página — el navegador dice cuál es, así que un documento no puede nombrar el archivo de otro. Nada sobre tus documentos se sube a ningún sitio, y la extensión tampoco tiene servidor al que subirlo.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAboutTitle": {
+ "message": "Acerca de"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · parte del proyecto Bento · licencia MIT"
+ },
+ "linkSource": {
+ "message": "Código en GitHub"
+ },
+ "linkIssues": {
+ "message": "Informar de un problema"
+ },
+ "linkReleases": {
+ "message": "Versiones"
+ },
+ "primeMiddle": {
+ "message": "la que dura"
+ },
+ "primeNote": {
+ "message": "Las otras dos también funcionan, pero Chrome vuelve a preguntar — la primera en cada reinicio, la última tras una espera."
+ }
+}
diff --git a/tray/webext/_locales/fa/messages.json b/tray/webext/_locales/fa/messages.json
new file mode 100644
index 00000000..c433afc0
--- /dev/null
+++ b/tray/webext/_locales/fa/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "سند Bento را بدون پرسش دربارهٔ مقصد، در همان فایلی که باز کرده‌اید ذخیره کنید."
+ },
+ "navAll": {
+ "message": "همهٔ سندها"
+ },
+ "navFolders": {
+ "message": "پوشه‌ها"
+ },
+ "navHelp": {
+ "message": "راهنما و درباره"
+ },
+ "navSettings": {
+ "message": "تنظیمات"
+ },
+ "addFolder": {
+ "message": "+ افزودن پوشه…"
+ },
+ "searchDocs": {
+ "message": "جست‌وجو در سندها"
+ },
+ "searchDocsSlash": {
+ "message": "جست‌وجو در سندها /"
+ },
+ "sortTitle": {
+ "message": "مرتب‌سازی"
+ },
+ "sortRecent": {
+ "message": "تغییریافته‌های اخیر"
+ },
+ "sortName": {
+ "message": "نام"
+ },
+ "sortFolder": {
+ "message": "پوشه"
+ },
+ "newDocument": {
+ "message": "+ سند تازه"
+ },
+ "browseAll": {
+ "message": "مرور همه"
+ },
+ "reconnectFolders": {
+ "message": "اتصال دوبارهٔ پوشه‌ها"
+ },
+ "primeIntro": {
+ "message": "Chrome همین حالا می‌پرسد. گزینهٔ میانی را انتخاب کنید:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — یک پوشه نیاز به اتصال دوباره دارد"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray نیاز به اتصال دوباره دارد"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome اجازهٔ یک پوشه را پس گرفت. تا بازگردانده نشود، هر بار ذخیره‌کردن از شما می‌پرسد فایل را کجا بگذارد."
+ },
+ "reconnect": {
+ "message": "اتصال دوباره"
+ },
+ "ctxOpenPanel": {
+ "message": "باز کردن پنل Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "هنوز سند Bento‌ای در پوشه‌های شما نیست."
+ },
+ "noMatches": {
+ "message": "چیزی با «$1» مطابقت ندارد"
+ },
+ "rowUnplacedTip": {
+ "message": "یک بار هر سندی را در $1 از Finder باز کنید تا هرچه در آن پوشه است از همین‌جا باز شود."
+ },
+ "encrypted": {
+ "message": "محافظت‌شده با گذرواژه"
+ },
+ "notSavedYet": {
+ "message": "هنوز ذخیره نشده"
+ },
+ "fileAccessOffShort": {
+ "message": "دسترسی به فایل‌های محلی خاموش است"
+ },
+ "noFoldersYet": {
+ "message": "هنوز پوشه‌ای نیست"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 پوشه نیاز به اتصال دوباره دارد"
+ },
+ "statusOneFolder": {
+ "message": "$1 پوشه · در جای خود ذخیره می‌کند"
+ },
+ "statusFolders": {
+ "message": "$1 پوشه · در جای خود ذخیره می‌کنند"
+ },
+ "renewNotOffered": {
+ "message": "Chrome بازگرداندن آن را پیشنهاد نکرد"
+ },
+ "renewTryAfterRestart": {
+ "message": "پس از راه‌اندازی دوبارهٔ Chrome دوباره تلاش کنید"
+ },
+ "fetchingLatest": {
+ "message": "در حال دریافت تازه‌ترین Bento…"
+ },
+ "created": {
+ "message": "$1 ساخته شد"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 خوانده می‌شود اما هنوز باز نمی‌شود — Chrome به افزونه نمی‌گوید یک پوشه کجای دیسک است. <b>مرور همه</b> آن‌ها را با یک کلیک پیدا می‌کند."
+ },
+ "andMore": {
+ "message": " و $1 مورد دیگر"
+ },
+ "agoJustNow": {
+ "message": "همین حالا"
+ },
+ "agoMinutes": {
+ "message": "$1 دقیقه پیش"
+ },
+ "agoHour": {
+ "message": "$1 ساعت پیش"
+ },
+ "agoHours": {
+ "message": "$1 ساعت پیش"
+ },
+ "agoDay": {
+ "message": "$1 روز پیش"
+ },
+ "agoDays": {
+ "message": "$1 روز پیش"
+ },
+ "searchScope": {
+ "message": "جست‌وجو عنوان‌ها، نام فایل‌ها، پوشه‌ها و واژه‌های درون سندها را می‌بیند."
+ },
+ "folderEmpty": {
+ "message": "هنوز چیزی در این پوشه نیست"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ سند تازه</b> یکی تازه اینجا می‌گذارد."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray هنوز نمی‌داند $1 کجای دیسک است. از «پوشه‌هایم را پیدا کن» استفاده کنید، یا یک بار سندی از آن را از Finder باز کنید."
+ },
+ "cardRenamedTip": {
+ "message": "$1 سند Bento‌ای با نامی دیگر است. از همین‌جا باز می‌شود، اما ذخیره‌کردن مقصد را می‌پرسد — ذخیرهٔ در جا تنها فایل‌هایی را می‌شناسد که به ‎.bento.html ختم می‌شوند."
+ },
+ "badgeRenamed": {
+ "message": "به‌جای ‎.bento.html با نام ‎.html — از همین‌جا باز می‌شود، اما ذخیره‌کردن مقصد را می‌پرسد."
+ },
+ "menuOpen": {
+ "message": "باز کردن"
+ },
+ "menuDuplicate": {
+ "message": "تکثیر"
+ },
+ "menuRename": {
+ "message": "تغییر نام…"
+ },
+ "menuCopyPath": {
+ "message": "رونوشت مسیر"
+ },
+ "duplicatedAs": {
+ "message": "با نام $1 تکثیر شد"
+ },
+ "renamePrompt": {
+ "message": "تغییر نام سند"
+ },
+ "renamedTo": {
+ "message": "نام به $1 تغییر کرد"
+ },
+ "pathCopied": {
+ "message": "مسیر رونوشت شد"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — هنوز باز نشده"
+ },
+ "setupTitle": {
+ "message": "دو کار و آماده‌اید"
+ },
+ "setupLead": {
+ "message": "پس از این، ⌘S در سندی که با دوبار کلیک باز کرده‌اید مستقیم در همان فایل می‌نویسد — دیگر هرگز مقصدی پرسیده نمی‌شود."
+ },
+ "chooseFolder": {
+ "message": "انتخاب پوشه…"
+ },
+ "setupStep1": {
+ "message": "پوشه‌ای را که سندهایتان در آن است انتخاب کنید"
+ },
+ "setupStep1Note": {
+ "message": "معمولاً یک پوشهٔ فراگیر کافی است — هرچه درونش باشد را می‌پوشاند."
+ },
+ "setupStep2": {
+ "message": "دسترسی به فایل‌های محلی را روشن کنید"
+ },
+ "setupStep2Note": {
+ "message": "در <code>chrome://extensions</code> ← Bento Tray ← <b>اجازهٔ دسترسی به نشانی‌های فایل</b>. Chrome به هیچ افزونه‌ای اجازه نمی‌دهد این را خودش روشن کند."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>ارتقا داده‌اید و انتظار داشتید پوشه‌هایتان اینجا باشند؟</b> افزونهٔ بازنشده با مسیر پوشه‌اش شناخته می‌شود، پس نسخهٔ تازه‌ای که از پوشه‌ای دیگر بارگذاری شود افزونه‌ای دیگر است. پوشه‌های شما هنوز به نسخهٔ قدیمی تعلق دارند. به‌جای آن فایل‌های پوشهٔ اصلی را جایگزین کنید و در <code>chrome://extensions</code> دکمهٔ <b>بارگذاری دوباره</b> را بزنید."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>دسترسی به فایل‌های محلی خاموش است</b> — تا روشن نشود چیزی در جای خود ذخیره نمی‌شود. <b>اجازهٔ دسترسی به نشانی‌های فایل</b> را در <code>chrome://extensions</code> روشن کنید."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 پوشه نیاز به اتصال دوباره دارد.</b> در <b>تنظیمات</b> دوباره متصلش کنید و <b>اجازه در هر بازدید</b> را انتخاب کنید — تنها گزینه‌ای که ماندگار است."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> فهرست می‌شود اما هنوز باز نمی‌شود — Chrome هرگز به افزونه نمی‌گوید یک پوشه کجای دیسک است."
+ },
+ "findFolders": {
+ "message": "پوشه‌هایم را پیدا کن"
+ },
+ "looking": {
+ "message": "در حال جست‌وجو…"
+ },
+ "findDeclined": {
+ "message": "<b>اشکالی ندارد.</b> به‌جایش یک بار سندی را در $1 از Finder باز کنید — این صفحه متوجه می‌شود."
+ },
+ "foundFolder": {
+ "message": "$1 پوشه پیدا شد"
+ },
+ "foundFolders": {
+ "message": "$1 پوشه پیدا شد"
+ },
+ "foundNothing": {
+ "message": "هنوز چیزی در تاریخچه نیست — یک سند را از Finder باز کنید"
+ },
+ "setFoldersSub": {
+ "message": "سندهای درون این‌ها بدون پرسش مقصد مستقیم در همان فایل ذخیره می‌شوند. یک پوشه هرچه درونش باشد را می‌پوشاند."
+ },
+ "noneYet": {
+ "message": "هنوز هیچ."
+ },
+ "savesInPlace": {
+ "message": "در جای خود ذخیره می‌کند"
+ },
+ "needsReconnecting": {
+ "message": "نیاز به اتصال دوباره دارد"
+ },
+ "reconnectTip": {
+ "message": "Chrome برای بازگرداندن این پوشه اجازه می‌خواهد. «اجازه نده» آن را رها می‌کند و پس از آن Chrome دست‌کم یک راه‌اندازی دوباره صبر می‌کند تا دوباره بپرسد."
+ },
+ "remove": {
+ "message": "حذف"
+ },
+ "removeTip": {
+ "message": "دسترسی را پس می‌گیرد. Chrome ممکن است اجازه را همچنان به یاد داشته باشد، پس افزودن دوبارهٔ پوشه شاید چیزی نپرسد."
+ },
+ "setAccessTitle": {
+ "message": "دسترسی به فایل‌های محلی"
+ },
+ "setAccessSub": {
+ "message": "Chrome به هیچ افزونه‌ای اجازه نمی‌دهد این را خودش روشن کند و بدون آن هیچ‌چیز کار نمی‌کند."
+ },
+ "stateOn": {
+ "message": "روشن"
+ },
+ "stateOff": {
+ "message": "خاموش"
+ },
+ "stateUnknown": {
+ "message": "نامعلوم"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray می‌تواند صفحه‌هایی را که از دیسک باز کرده‌اید بخواند."
+ },
+ "accessOffNote": {
+ "message": "chrome://extensions را باز کنید، Bento Tray را بیابید و «اجازهٔ دسترسی به نشانی‌های فایل» را روشن کنید."
+ },
+ "accessUnknownNote": {
+ "message": "این مرورگر آن را گزارش نمی‌کند. اگر ذخیره‌کردن هنوز می‌پرسد، در chrome://extensions بررسی کنید."
+ },
+ "setVersionTitle": {
+ "message": "نسخه"
+ },
+ "setVersionUnpacked": {
+ "message": "این نسخه بازنشده بارگذاری شده، پس Chrome هرگز به‌روزش نمی‌کند."
+ },
+ "setVersionStore": {
+ "message": "از فروشگاه نصب شده، پس خودش را به‌روز می‌کند."
+ },
+ "versionAvailable": {
+ "message": "$1 در دسترس است"
+ },
+ "versionUpToDate": {
+ "message": "بر پایهٔ آخرین بررسی به‌روز است"
+ },
+ "versionManaged": {
+ "message": "مرورگر آن را به‌روز نگه می‌دارد"
+ },
+ "getIt": {
+ "message": "دریافت"
+ },
+ "checkNow": {
+ "message": "همین حالا بررسی کن"
+ },
+ "autoCheckPref": {
+ "message": "<b>هنگام آغاز مرورگر نسخهٔ تازه را بررسی کن.</b><br>یک درخواست به bento.page برای یک فایل ایستا. هیچ شناسه‌ای، شماره نسخه‌ای یا چیزی دربارهٔ سندهای شما نمی‌فرستد — مقایسه همین‌جا انجام می‌شود. خاموشش کنید و هرگز چیزی درخواست نمی‌شود؛ <b>همین حالا بررسی کن</b> همچنان کار می‌کند."
+ },
+ "expectedSha": {
+ "message": "SHA-256 مورد انتظار برای فایل zip: $1"
+ },
+ "setReachTitle": {
+ "message": "دسترسی‌اش تا کجاست"
+ },
+ "setReachSub": {
+ "message": "تنها پوشه‌های بالا، و تنها همان فایلی که صفحه واقعاً از آن باز شده است. چیزی بارگذاری نمی‌شود و جای دیگری چیزی خوانده نمی‌شود."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 در دسترس است.</b> این نسخه بازنشده بارگذاری شده، پس Chrome هرگز به‌روزش نمی‌کند."
+ },
+ "updateStep1": {
+ "message": "آن را از GitHub دانلود کنید"
+ },
+ "updateStep2": {
+ "message": "فایل‌ها را <b>در همان پوشه‌ای که از آن بارگذاری کردید</b> جایگزین کنید — همان پوشه، وگرنه Chrome آن را افزونه‌ای دیگر می‌شمارد و پوشه‌های اجازه‌داده‌شده همراهش نمی‌آیند"
+ },
+ "updateStep3": {
+ "message": "<code>chrome://extensions</code> را باز کنید و روی Bento Tray دکمهٔ <b>بارگذاری دوباره</b> را بزنید"
+ },
+ "fetchingApp": {
+ "message": "در حال دریافت $1…"
+ },
+ "createdIn": {
+ "message": "$1 ($2) در $3 ساخته شد"
+ },
+ "intoFolder": {
+ "message": "در $1"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray چه می‌کند"
+ },
+ "helpWhatSub": {
+ "message": "سند Bento یک فایل HTML است که ویرایشگر خودش را با خود دارد. وقتی مستقیم از دیسک باز شود، مرورگر نمی‌گذارد در خودش بنویسد — پس ذخیره‌کردن هر بار می‌پرسد کجا بگذاردش. Bento Tray همان پرسش را برمی‌دارد."
+ },
+ "tourSaveTitle": {
+ "message": "ذخیره در جای خود"
+ },
+ "tourSaveBody": {
+ "message": "⌘S بدون هیچ کادر گفت‌وگویی مستقیم در همان فایلی که باز کرده‌اید می‌نویسد. ذخیرهٔ خودکار و به‌روزرسانی‌های در جا هم از همین راه می‌روند."
+ },
+ "tourFindTitle": {
+ "message": "سندهایتان را پیدا کنید"
+ },
+ "tourFindBody": {
+ "message": "هر سند Bento در پوشه‌هایتان، با عنوان واقعی‌اش و تصویری از صفحهٔ نخستش. جست‌وجو آنچه را درونشان نوشته شده هم دربر می‌گیرد."
+ },
+ "tourSwitchTitle": {
+ "message": "هنگام کار جابه‌جا شوید"
+ },
+ "tourSwitchBody": {
+ "message": "<kbd>Alt</kbd>+<kbd>B</kbd> را بزنید، یا درون یک سند راست‌کلیک کنید، تا پنلی کنارش باز شود."
+ },
+ "tourNewTitle": {
+ "message": "یکی تازه بسازید"
+ },
+ "tourNewBody": {
+ "message": "<b>+ سند تازه</b> نسخهٔ کنونی Slides، Spaces یا Dash را می‌آورد و سندی تازه در پوشهٔ شما می‌گذارد."
+ },
+ "helpNeedsTitle": {
+ "message": "چه چیزی از شما می‌خواهد"
+ },
+ "helpNeedsSub": {
+ "message": "دو چیز، که هیچ‌کدام در توان این افزونه نیست خودش ترتیبش را بدهد."
+ },
+ "helpFolder": {
+ "message": "یک پوشه"
+ },
+ "helpFolderGranted": {
+ "message": "$1 اجازه داده شده — سندهای درونشان در جای خود ذخیره می‌شوند"
+ },
+ "helpFolderNone": {
+ "message": "هنوز انتخاب نشده. یک پوشهٔ فراگیر هرچه درونش باشد را می‌پوشاند."
+ },
+ "helpAccessOff": {
+ "message": "خاموش. <b>اجازهٔ دسترسی به نشانی‌های فایل</b> را در <code>chrome://extensions</code> روشن کنید — هیچ افزونه‌ای نمی‌تواند این را خودش روشن کند."
+ },
+ "helpAccessUnknown": {
+ "message": "این مرورگر آن را گزارش نمی‌کند. اگر ذخیره‌کردن هنوز می‌پرسد، در <code>chrome://extensions</code> بررسی کنید."
+ },
+ "helpAccessOn": {
+ "message": "روشن — Bento Tray می‌تواند صفحه‌هایی را که از دیسک باز کرده‌اید بخواند."
+ },
+ "helpNeverTitle": {
+ "message": "چه کاری هرگز نمی‌کند"
+ },
+ "helpNeverSub": {
+ "message": "تنها درون پوشه‌های بالا می‌خواند و می‌نویسد، و تنها همان فایلی را که صفحه واقعاً از آن باز شده است — مرورگر می‌گوید کدام، پس سندی نمی‌تواند نام فایل کس دیگری را ببرد. هیچ‌چیز دربارهٔ سندهای شما به جایی بارگذاری نمی‌شود، و افزونه اصلاً سروری برای بارگذاری آن‌ها ندارد."
+ },
+ "helpAboutTitle": {
+ "message": "درباره"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · بخشی از پروژهٔ Bento · با پروانهٔ MIT"
+ },
+ "linkSource": {
+ "message": "کد منبع در GitHub"
+ },
+ "linkIssues": {
+ "message": "گزارش مشکل"
+ },
+ "linkReleases": {
+ "message": "انتشارها"
+ },
+ "primeMiddle": {
+ "message": "گزینه‌ای که ماندگار است"
+ },
+ "primeNote": {
+ "message": "دو گزینهٔ دیگر هم کار می‌کنند، اما Chrome دوباره می‌پرسد — برای اولی در هر راه‌اندازی دوباره، و برای آخری پس از مدتی انتظار."
+ }
+}
diff --git a/tray/webext/_locales/fi/messages.json b/tray/webext/_locales/fi/messages.json
new file mode 100644
index 00000000..5d3209e6
--- /dev/null
+++ b/tray/webext/_locales/fi/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Tallenna Bento-asiakirja takaisin avaamaasi tiedostoon kysymättä sijaintia."
+ },
+ "navAll": {
+ "message": "Kaikki asiakirjat"
+ },
+ "navFolders": {
+ "message": "Kansiot"
+ },
+ "navHelp": {
+ "message": "Ohje ja tietoja"
+ },
+ "navSettings": {
+ "message": "Asetukset"
+ },
+ "addFolder": {
+ "message": "+ Lisää kansio…"
+ },
+ "searchDocs": {
+ "message": "Hae asiakirjoista"
+ },
+ "searchDocsSlash": {
+ "message": "Hae asiakirjoista /"
+ },
+ "sortTitle": {
+ "message": "Lajittele"
+ },
+ "sortRecent": {
+ "message": "Viimeksi muutettu"
+ },
+ "sortName": {
+ "message": "Nimi"
+ },
+ "sortFolder": {
+ "message": "Kansio"
+ },
+ "newDocument": {
+ "message": "+ Uusi asiakirja"
+ },
+ "browseAll": {
+ "message": "Selaa kaikkia"
+ },
+ "reconnectFolders": {
+ "message": "Yhdistä kansiot uudelleen"
+ },
+ "primeIntro": {
+ "message": "Chrome kysyy kohta. Valitse keskimmäinen vaihtoehto:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — kansio täytyy yhdistää uudelleen"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray täytyy yhdistää uudelleen"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome poisti kansion käyttöoikeuden. Ennen sen palauttamista jokainen tallennus kysyy, mihin tiedosto sijoitetaan."
+ },
+ "reconnect": {
+ "message": "Yhdistä uudelleen"
+ },
+ "ctxOpenPanel": {
+ "message": "Avaa Bento Tray -paneeli"
+ },
+ "panelEmpty": {
+ "message": "Kansioissasi ei ole vielä Bento-asiakirjoja."
+ },
+ "noMatches": {
+ "message": "Mikään ei vastaa hakua ”$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Avaa yksi asiakirja kansiosta $1 kerran Finderissa, niin kaikki siinä kansiossa avautuu täältä."
+ },
+ "encrypted": {
+ "message": "Salasanasuojattu"
+ },
+ "notSavedYet": {
+ "message": "Ei vielä tallennettu"
+ },
+ "fileAccessOffShort": {
+ "message": "Paikallisten tiedostojen käyttö on pois päältä"
+ },
+ "noFoldersYet": {
+ "message": "Ei vielä kansioita"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 kansio täytyy yhdistää uudelleen"
+ },
+ "statusOneFolder": {
+ "message": "$1 kansio · tallentaa paikalleen"
+ },
+ "statusFolders": {
+ "message": "$1 kansiota · tallentavat paikalleen"
+ },
+ "renewNotOffered": {
+ "message": "Chrome ei tarjoutunut palauttamaan sitä"
+ },
+ "renewTryAfterRestart": {
+ "message": "Yritä uudelleen käynnistettyäsi Chromen uudelleen"
+ },
+ "fetchingLatest": {
+ "message": "Haetaan uusinta Bentoa…"
+ },
+ "created": {
+ "message": "$1 luotu"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 voidaan lukea, mutta ei vielä avata — Chrome ei kerro laajennukselle, missä kansio levyllä sijaitsee. <b>Selaa kaikkia</b> löytää ne yhdellä napsautuksella."
+ },
+ "andMore": {
+ "message": " ja $1 muuta"
+ },
+ "agoJustNow": {
+ "message": "juuri nyt"
+ },
+ "agoMinutes": {
+ "message": "$1 min sitten"
+ },
+ "agoHour": {
+ "message": "$1 tunti sitten"
+ },
+ "agoHours": {
+ "message": "$1 tuntia sitten"
+ },
+ "agoDay": {
+ "message": "$1 päivä sitten"
+ },
+ "agoDays": {
+ "message": "$1 päivää sitten"
+ },
+ "searchScope": {
+ "message": "Haku katsoo otsikoita, tiedostonimiä, kansioita ja asiakirjojen sisällä olevia sanoja."
+ },
+ "folderEmpty": {
+ "message": "Tässä kansiossa ei ole vielä mitään"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Uusi asiakirja</b> luo tänne uuden."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray ei vielä tiedä, missä $1 on levyllä. Käytä ”Etsi kansioni” tai avaa siitä yksi asiakirja Finderissa kerran."
+ },
+ "cardRenamedTip": {
+ "message": "$1 on Bento-asiakirja toisella nimellä. Se avautuu täältä, mutta tallennus kysyy sijaintia — paikalleen tallennus tunnistaa vain tiedostot, joiden pääte on .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Nimenä .html eikä .bento.html — avautuu täältä, mutta tallennus kysyy sijaintia."
+ },
+ "menuOpen": {
+ "message": "Avaa"
+ },
+ "menuDuplicate": {
+ "message": "Monista"
+ },
+ "menuRename": {
+ "message": "Nimeä uudelleen…"
+ },
+ "menuCopyPath": {
+ "message": "Kopioi polku"
+ },
+ "duplicatedAs": {
+ "message": "Monistettu nimellä $1"
+ },
+ "renamePrompt": {
+ "message": "Nimeä asiakirja uudelleen"
+ },
+ "renamedTo": {
+ "message": "Nimettiin $1"
+ },
+ "pathCopied": {
+ "message": "Polku kopioitu"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — ei vielä avattu"
+ },
+ "setupTitle": {
+ "message": "Kaksi asiaa, ja olet valmis"
+ },
+ "setupLead": {
+ "message": "Sen jälkeen ⌘S kaksoisnapsautuksella avatussa asiakirjassa kirjoittaa suoraan takaisin tiedostoon — sijaintia ei kysytä enää koskaan."
+ },
+ "chooseFolder": {
+ "message": "Valitse kansio…"
+ },
+ "setupStep1": {
+ "message": "Valitse kansio, jossa asiakirjasi ovat"
+ },
+ "setupStep1Note": {
+ "message": "Yksi laaja kansio riittää yleensä — se kattaa kaiken sen sisällä."
+ },
+ "setupStep2": {
+ "message": "Ota paikallisten tiedostojen käyttö käyttöön"
+ },
+ "setupStep2Note": {
+ "message": "Kohdassa <code>chrome://extensions</code> → Bento Tray → <b>Salli tiedosto-URL-osoitteiden käyttö</b>. Chrome ei anna laajennuksen ottaa tätä käyttöön itse."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Päivititkö ja odotit kansioidesi olevan täällä?</b> Purettu laajennus tunnistetaan kansiopolustaan, joten toisesta kansiosta ladattu uusi kopio on eri laajennus. Kansiosi kuuluvat yhä vanhalle. Korvaa sen sijaan alkuperäisen kansion tiedostot ja paina <b>Lataa uudelleen</b> kohdassa <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Paikallisten tiedostojen käyttö on pois päältä</b> — mitään ei tallenneta paikalleen ennen kuin se on päällä. Ota <b>Salli tiedosto-URL-osoitteiden käyttö</b> käyttöön kohdassa <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 kansio täytyy yhdistää uudelleen.</b> Yhdistä se uudelleen kohdassa <b>Asetukset</b> ja valitse <b>Salli joka käynnillä</b> — ainoa vaihtoehto, joka kestää."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> voidaan luetella, mutta ei vielä avata — Chrome ei koskaan kerro laajennukselle, missä kansio levyllä sijaitsee."
+ },
+ "findFolders": {
+ "message": "Etsi kansioni"
+ },
+ "looking": {
+ "message": "Etsitään…"
+ },
+ "findDeclined": {
+ "message": "<b>Ei se mitään.</b> Avaa sen sijaan yksi asiakirja kansiosta $1 Finderissa kerran — tämä sivu huomaa sen."
+ },
+ "foundFolder": {
+ "message": "Löytyi $1 kansio"
+ },
+ "foundFolders": {
+ "message": "Löytyi $1 kansiota"
+ },
+ "foundNothing": {
+ "message": "Historiassa ei ole vielä mitään — avaa yksi asiakirja Finderissa"
+ },
+ "setFoldersSub": {
+ "message": "Näiden asiakirjat tallentuvat suoraan takaisin tiedostoon ilman sijaintikysymystä. Kansio kattaa kaiken sen sisällä."
+ },
+ "noneYet": {
+ "message": "Ei vielä yhtään."
+ },
+ "savesInPlace": {
+ "message": "tallentaa paikalleen"
+ },
+ "needsReconnecting": {
+ "message": "täytyy yhdistää uudelleen"
+ },
+ "reconnectTip": {
+ "message": "Chrome kysyy, palautetaanko tämä kansio. ”Älä salli” hylkää sen, ja sen jälkeen Chrome odottaa vähintään uudelleenkäynnistyksen ennen kuin kysyy uudelleen."
+ },
+ "remove": {
+ "message": "Poista"
+ },
+ "removeTip": {
+ "message": "Poistaa käyttöoikeuden. Chrome saattaa silti muistaa luvan, joten kansion lisääminen takaisin ei ehkä kysy uudelleen."
+ },
+ "setAccessTitle": {
+ "message": "Paikallisten tiedostojen käyttö"
+ },
+ "setAccessSub": {
+ "message": "Chrome ei anna laajennuksen ottaa tätä käyttöön itse, eikä mikään toimi ilman sitä."
+ },
+ "stateOn": {
+ "message": "Päällä"
+ },
+ "stateOff": {
+ "message": "Pois"
+ },
+ "stateUnknown": {
+ "message": "Tuntematon"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray voi lukea sivuja, jotka avasit levyltä."
+ },
+ "accessOffNote": {
+ "message": "Avaa chrome://extensions, etsi Bento Tray ja ota käyttöön ”Salli tiedosto-URL-osoitteiden käyttö”."
+ },
+ "accessUnknownNote": {
+ "message": "Tämä selain ei kerro sitä. Jos tallennus yhä kysyy, tarkista se kohdassa chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Versio"
+ },
+ "setVersionUnpacked": {
+ "message": "Tämä kopio ladattiin purettuna, joten Chrome ei koskaan päivitä sitä."
+ },
+ "setVersionStore": {
+ "message": "Asennettu kaupasta, joten se päivittää itsensä."
+ },
+ "versionAvailable": {
+ "message": "$1 on saatavilla"
+ },
+ "versionUpToDate": {
+ "message": "ajan tasalla viimeisimmän tarkistuksen mukaan"
+ },
+ "versionManaged": {
+ "message": "selain pitää ajan tasalla"
+ },
+ "getIt": {
+ "message": "Hae se"
+ },
+ "checkNow": {
+ "message": "Tarkista nyt"
+ },
+ "autoCheckPref": {
+ "message": "<b>Tarkista uusi versio, kun selain käynnistyy.</b><br>Yksi pyyntö osoitteeseen bento.page staattisesta tiedostosta. Se ei lähetä tunnisteita, versionumeroa eikä mitään asiakirjoistasi — vertailu tehdään täällä. Ota pois päältä, eikä mitään pyydetä koskaan; <b>Tarkista nyt</b> toimii silti."
+ },
+ "expectedSha": {
+ "message": "Zip-tiedoston odotettu SHA-256: $1"
+ },
+ "setReachTitle": {
+ "message": "Mihin tämä yltää"
+ },
+ "setReachSub": {
+ "message": "Vain yllä oleviin kansioihin ja vain siihen tiedostoon, josta sivu todella avattiin. Mitään ei lähetetä eikä mitään lueta muualta."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 on saatavilla.</b> Tämä kopio ladattiin purettuna, joten Chrome ei koskaan päivitä sitä."
+ },
+ "updateStep1": {
+ "message": "Lataa se GitHubista"
+ },
+ "updateStep2": {
+ "message": "Korvaa tiedostot <b>siinä kansiossa, josta latasit sen</b> — samassa kansiossa, tai Chrome pitää sitä eri laajennuksena eivätkä myönnetyt kansiosi seuraa mukana"
+ },
+ "updateStep3": {
+ "message": "Avaa <code>chrome://extensions</code> ja paina Bento Trayn kohdalla <b>Lataa uudelleen</b>"
+ },
+ "fetchingApp": {
+ "message": "Haetaan $1…"
+ },
+ "createdIn": {
+ "message": "Luotiin $1 ($2) kansioon $3"
+ },
+ "intoFolder": {
+ "message": "kansioon $1"
+ },
+ "helpWhatTitle": {
+ "message": "Mitä Bento Tray tekee"
+ },
+ "helpWhatSub": {
+ "message": "Bento-asiakirja on yksi HTML-tiedosto, joka kantaa oman editorinsa. Suoraan levyltä avattuna selain ei anna sen kirjoittaa takaisin itseensä — joten tallennus kysyy joka kerta sijaintia. Bento Tray poistaa tuon kysymyksen."
+ },
+ "tourSaveTitle": {
+ "message": "Tallenna paikalleen"
+ },
+ "tourSaveBody": {
+ "message": "⌘S kirjoittaa suoraan takaisin avaamaasi tiedostoon ilman valintaikkunaa. Automaattitallennus ja paikalleen tehdyt päivitykset kulkevat samaa reittiä."
+ },
+ "tourFindTitle": {
+ "message": "Löydä asiakirjasi"
+ },
+ "tourFindBody": {
+ "message": "Jokainen Bento-asiakirja kansioissasi, oikealla otsikollaan ja kuvalla ensimmäisestä sivusta. Haku kattaa myös sen, mitä niiden sisällä lukee."
+ },
+ "tourSwitchTitle": {
+ "message": "Vaihda työn lomassa"
+ },
+ "tourSwitchBody": {
+ "message": "Paina <kbd>Alt</kbd>+<kbd>B</kbd> tai napsauta asiakirjan sisällä hiiren oikealla — paneeli avautuu viereen."
+ },
+ "tourNewTitle": {
+ "message": "Tee uusi"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Uusi asiakirja</b> hakee Slidesin, Spacesin tai Dashin nykyisen julkaisun ja luo uuden asiakirjan kansioosi."
+ },
+ "helpNeedsTitle": {
+ "message": "Mitä se tarvitsee sinulta"
+ },
+ "helpNeedsSub": {
+ "message": "Kaksi asiaa, joita kumpaakaan tämä laajennus ei voi itse järjestää."
+ },
+ "helpFolder": {
+ "message": "Kansio"
+ },
+ "helpFolderGranted": {
+ "message": "$1 myönnetty — niiden sisällä olevat asiakirjat tallentuvat paikalleen"
+ },
+ "helpFolderNone": {
+ "message": "Ei vielä valittu. Yksi laaja kansio kattaa kaiken sen sisällä."
+ },
+ "helpAccessOff": {
+ "message": "Pois. Ota <b>Salli tiedosto-URL-osoitteiden käyttö</b> käyttöön kohdassa <code>chrome://extensions</code> — mikään laajennus ei voi ottaa tätä käyttöön itse."
+ },
+ "helpAccessUnknown": {
+ "message": "Tämä selain ei kerro sitä. Jos tallennus yhä kysyy, tarkista se kohdassa <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Päällä — Bento Tray voi lukea sivuja, jotka avasit levyltä."
+ },
+ "helpNeverTitle": {
+ "message": "Mitä se ei koskaan tee"
+ },
+ "helpNeverSub": {
+ "message": "Se lukee ja kirjoittaa vain yllä olevien kansioiden sisällä ja vain sen tiedoston, josta sivu todella avattiin — selain kertoo kumman, joten asiakirja ei voi nimetä jonkun toisen tiedostoa. Mitään asiakirjoistasi ei lähetetä minnekään, eikä laajennuksella ole palvelinta, jonne ne lähetettäisiin."
+ },
+ "helpAboutTitle": {
+ "message": "Tietoja"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · osa Bento-projektia · MIT-lisenssi"
+ },
+ "linkSource": {
+ "message": "Lähdekoodi GitHubissa"
+ },
+ "linkIssues": {
+ "message": "Ilmoita ongelmasta"
+ },
+ "linkReleases": {
+ "message": "Julkaisut"
+ },
+ "primeMiddle": {
+ "message": "se, joka kestää"
+ },
+ "primeNote": {
+ "message": "Kaksi muutakin toimivat, mutta Chrome kysyy uudelleen — ensimmäisessä joka käynnistyksellä ja viimeisessä odotusajan jälkeen."
+ }
+}
diff --git a/tray/webext/_locales/fil/messages.json b/tray/webext/_locales/fil/messages.json
new file mode 100644
index 00000000..218217b5
--- /dev/null
+++ b/tray/webext/_locales/fil/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "I-save ang dokumentong Bento pabalik sa mismong file na binuksan mo, nang hindi tinatanong kung saan."
+ },
+ "navAll": {
+ "message": "Lahat ng dokumento"
+ },
+ "navFolders": {
+ "message": "Mga folder"
+ },
+ "navHelp": {
+ "message": "Tulong at tungkol"
+ },
+ "navSettings": {
+ "message": "Mga setting"
+ },
+ "addFolder": {
+ "message": "+ Magdagdag ng folder…"
+ },
+ "searchDocs": {
+ "message": "Maghanap ng dokumento"
+ },
+ "searchDocsSlash": {
+ "message": "Maghanap ng dokumento /"
+ },
+ "sortTitle": {
+ "message": "Ayusin"
+ },
+ "sortRecent": {
+ "message": "Kamakailang binago"
+ },
+ "sortName": {
+ "message": "Pangalan"
+ },
+ "sortFolder": {
+ "message": "Folder"
+ },
+ "newDocument": {
+ "message": "+ Bagong dokumento"
+ },
+ "browseAll": {
+ "message": "Tingnan lahat"
+ },
+ "reconnectFolders": {
+ "message": "Muling ikonekta ang mga folder"
+ },
+ "primeIntro": {
+ "message": "Magtatanong ang Chrome. Piliin ang nasa gitna:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — may folder na kailangang ikonekta muli"
+ },
+ "notifyLapsedTitle": {
+ "message": "Kailangang ikonekta muli ang Bento Tray"
+ },
+ "notifyLapsedBody": {
+ "message": "Binawi ng Chrome ang pahintulot sa isang folder. Hangga't hindi naibabalik, tatanungin ka sa bawat pag-save kung saan ilalagay ang file."
+ },
+ "reconnect": {
+ "message": "Ikonekta muli"
+ },
+ "ctxOpenPanel": {
+ "message": "Buksan ang panel ng Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "Wala pang dokumentong Bento sa mga folder mo."
+ },
+ "noMatches": {
+ "message": "Walang tumutugma sa “$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Buksan minsan ang kahit isang dokumento sa $1 mula sa Finder, at mabubuksan na rito ang lahat ng laman ng folder na iyon."
+ },
+ "encrypted": {
+ "message": "Protektado ng password"
+ },
+ "notSavedYet": {
+ "message": "Hindi pa na-save"
+ },
+ "fileAccessOffShort": {
+ "message": "Naka-off ang access sa lokal na file"
+ },
+ "noFoldersYet": {
+ "message": "Wala pang folder"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 folder ang kailangang ikonekta muli"
+ },
+ "statusOneFolder": {
+ "message": "$1 folder · nagsi-save sa mismong file"
+ },
+ "statusFolders": {
+ "message": "$1 folder · nagsi-save sa mismong file"
+ },
+ "renewNotOffered": {
+ "message": "Hindi nag-alok ang Chrome na ibalik ito"
+ },
+ "renewTryAfterRestart": {
+ "message": "Subukan muli pagkatapos i-restart ang Chrome"
+ },
+ "fetchingLatest": {
+ "message": "Kinukuha ang pinakabagong Bento…"
+ },
+ "created": {
+ "message": "Nalikha ang $1"
+ },
+ "panelUnplaced": {
+ "message": "Nababasa ang <b>$1</b>$2 pero hindi pa nabubuksan — hindi sinasabi ng Chrome sa isang extension kung nasaan sa disk ang isang folder. Mahahanap sila ng <b>Tingnan lahat</b> sa isang klik."
+ },
+ "andMore": {
+ "message": " at $1 pa"
+ },
+ "agoJustNow": {
+ "message": "kanina lang"
+ },
+ "agoMinutes": {
+ "message": "$1 min ang nakalipas"
+ },
+ "agoHour": {
+ "message": "$1 oras ang nakalipas"
+ },
+ "agoHours": {
+ "message": "$1 oras ang nakalipas"
+ },
+ "agoDay": {
+ "message": "$1 araw ang nakalipas"
+ },
+ "agoDays": {
+ "message": "$1 araw ang nakalipas"
+ },
+ "searchScope": {
+ "message": "Tinitingnan ng paghahanap ang mga pamagat, pangalan ng file, folder, at mga salitang nasa loob ng dokumento."
+ },
+ "folderEmpty": {
+ "message": "Wala pang laman ang folder na ito"
+ },
+ "folderEmptyHint": {
+ "message": "Maglalagay ng bago rito ang <b>+ Bagong dokumento</b>."
+ },
+ "cardUnplacedTip": {
+ "message": "Hindi pa alam ng Bento Tray kung nasaan sa disk ang $1. Gamitin ang “Hanapin ang mga folder ko”, o buksan minsan mula sa Finder ang kahit anong dokumento roon."
+ },
+ "cardRenamedTip": {
+ "message": "Ang $1 ay dokumentong Bento na may ibang pangalan. Nabubuksan ito rito, pero magtatanong ang pag-save kung saan ilalagay — mga file lang na nagtatapos sa .bento.html ang nakikilala ng pag-save sa mismong file."
+ },
+ "badgeRenamed": {
+ "message": "Pinangalanang .html sa halip na .bento.html — nabubuksan ito rito, pero magtatanong ang pag-save kung saan ilalagay."
+ },
+ "menuOpen": {
+ "message": "Buksan"
+ },
+ "menuDuplicate": {
+ "message": "Gumawa ng kopya"
+ },
+ "menuRename": {
+ "message": "Palitan ang pangalan…"
+ },
+ "menuCopyPath": {
+ "message": "Kopyahin ang path"
+ },
+ "duplicatedAs": {
+ "message": "Kinopya bilang $1"
+ },
+ "renamePrompt": {
+ "message": "Palitan ang pangalan ng dokumento"
+ },
+ "renamedTo": {
+ "message": "Pinalitan ng pangalang $1"
+ },
+ "pathCopied": {
+ "message": "Nakopya ang path"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — hindi pa nabubuksan"
+ },
+ "setupTitle": {
+ "message": "Dalawang bagay at handa ka na"
+ },
+ "setupLead": {
+ "message": "Pagkatapos nito, ang ⌘S sa dokumentong binuksan mo sa pamamagitan ng dobleng pag-klik ay direktang isusulat pabalik sa file — wala nang tanong kung saan, kailanman."
+ },
+ "chooseFolder": {
+ "message": "Pumili ng folder…"
+ },
+ "setupStep1": {
+ "message": "Piliin ang folder kung saan naroon ang mga dokumento mo"
+ },
+ "setupStep1Note": {
+ "message": "Kadalasan ay sapat na ang isang malawak na folder — saklaw nito ang lahat ng nasa loob."
+ },
+ "setupStep2": {
+ "message": "I-on ang access sa lokal na file"
+ },
+ "setupStep2Note": {
+ "message": "Sa <code>chrome://extensions</code> → Bento Tray → <b>Payagan ang access sa mga file URL</b>. Hindi pinapayagan ng Chrome na i-on ito ng extension para sa sarili nito."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Nag-upgrade at inaasahang naririto ang mga folder mo?</b> Ang isang unpacked na extension ay kinikilala sa pamamagitan ng path ng folder nito, kaya't ang bagong kopyang na-load mula sa ibang folder ay ibang extension na. Nasa lumang kopya pa rin ang mga folder mo. Sa halip, palitan ang mga file sa orihinal na folder at pindutin ang <b>I-reload</b> sa <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Naka-off ang access sa lokal na file</b> — walang mase-save sa mismong file hangga't hindi ito naka-on. I-on ang <b>Payagan ang access sa mga file URL</b> sa <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 folder ang kailangang ikonekta muli.</b> Ikonekta itong muli sa <b>Mga setting</b>, at piliin ang <b>Payagan sa bawat pagbisita</b> — ito lang ang pagpipiliang nananatili."
+ },
+ "noticeUnplaced": {
+ "message": "Nakalilista ang <b>$1</b> pero hindi pa nabubuksan — hindi kailanman sinasabi ng Chrome sa isang extension kung nasaan sa disk ang isang folder."
+ },
+ "findFolders": {
+ "message": "Hanapin ang mga folder ko"
+ },
+ "looking": {
+ "message": "Naghahanap…"
+ },
+ "findDeclined": {
+ "message": "<b>Walang problema.</b> Sa halip, buksan minsan mula sa Finder ang kahit anong dokumento sa $1 — mapapansin ito ng pahinang ito."
+ },
+ "foundFolder": {
+ "message": "Nakahanap ng $1 folder"
+ },
+ "foundFolders": {
+ "message": "Nakahanap ng $1 folder"
+ },
+ "foundNothing": {
+ "message": "Wala pang laman ang kasaysayan — magbukas ng isang dokumento mula sa Finder"
+ },
+ "setFoldersSub": {
+ "message": "Ang mga dokumentong nasa mga ito ay direktang nase-save pabalik sa file, nang hindi tinatanong kung saan. Saklaw ng isang folder ang lahat ng nasa loob nito."
+ },
+ "noneYet": {
+ "message": "Wala pa."
+ },
+ "savesInPlace": {
+ "message": "nagsi-save sa mismong file"
+ },
+ "needsReconnecting": {
+ "message": "kailangang ikonekta muli"
+ },
+ "reconnectTip": {
+ "message": "Hihingi ang Chrome ng pahintulot na ibalik ang folder na ito. Binibitawan ito ng “Huwag payagan”, at pagkatapos ay maghihintay ang Chrome ng kahit isang restart bago muling magtanong."
+ },
+ "remove": {
+ "message": "Alisin"
+ },
+ "removeTip": {
+ "message": "Binabawi ang access. Maaaring tandaan pa rin ng Chrome ang pahintulot, kaya't baka hindi na magtanong kapag ibinalik mo ang folder."
+ },
+ "setAccessTitle": {
+ "message": "Access sa lokal na file"
+ },
+ "setAccessSub": {
+ "message": "Hindi pinapayagan ng Chrome na i-on ito ng extension para sa sarili nito, at walang gumagana kung wala ito."
+ },
+ "stateOn": {
+ "message": "Naka-on"
+ },
+ "stateOff": {
+ "message": "Naka-off"
+ },
+ "stateUnknown": {
+ "message": "Hindi alam"
+ },
+ "accessOnNote": {
+ "message": "Nababasa ng Bento Tray ang mga pahinang binuksan mo mula sa disk."
+ },
+ "accessOffNote": {
+ "message": "Buksan ang chrome://extensions, hanapin ang Bento Tray, i-on ang “Payagan ang access sa mga file URL”."
+ },
+ "accessUnknownNote": {
+ "message": "Hindi ito iniuulat ng browser na ito. Kung nagtatanong pa rin ang pag-save, tingnan ito sa chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Bersyon"
+ },
+ "setVersionUnpacked": {
+ "message": "Na-load ang kopyang ito nang unpacked, kaya't hindi ito kailanman i-a-update ng Chrome."
+ },
+ "setVersionStore": {
+ "message": "Na-install mula sa store, kaya't ina-update nito ang sarili."
+ },
+ "versionAvailable": {
+ "message": "Available na ang $1"
+ },
+ "versionUpToDate": {
+ "message": "pinakabago noong huling pagsusuri"
+ },
+ "versionManaged": {
+ "message": "pinananatiling bago ng browser"
+ },
+ "getIt": {
+ "message": "Kunin"
+ },
+ "checkNow": {
+ "message": "Tingnan ngayon"
+ },
+ "autoCheckPref": {
+ "message": "<b>Maghanap ng bagong bersyon kapag nagsimula ang browser.</b><br>Isang kahilingan sa bento.page para sa isang static na file. Wala itong ipinapadalang pagkakakilanlan, numero ng bersyon, o anuman tungkol sa mga dokumento mo — dito mismo nangyayari ang paghahambing. I-off ito at wala nang kahit anong hihilingin; gumagana pa rin ang <b>Tingnan ngayon</b>."
+ },
+ "expectedSha": {
+ "message": "Inaasahang SHA-256 ng zip: $1"
+ },
+ "setReachTitle": {
+ "message": "Ano ang naaabot nito"
+ },
+ "setReachSub": {
+ "message": "Ang mga folder lang sa itaas, at ang file lang na talagang pinagbuksan ng isang pahina. Walang ina-upload at walang binabasa saanman."
+ },
+ "updateAvailable": {
+ "message": "<b>Available na ang Bento Tray $1.</b> Na-load ang kopyang ito nang unpacked, kaya't hindi ito kailanman i-a-update ng Chrome."
+ },
+ "updateStep1": {
+ "message": "I-download ito mula sa GitHub"
+ },
+ "updateStep2": {
+ "message": "Palitan ang mga file <b>sa folder na pinag-load-an mo nito</b> — sa parehong folder, o ituturing ito ng Chrome na ibang extension at hindi kasama ang mga folder na binigyan mo ng pahintulot"
+ },
+ "updateStep3": {
+ "message": "Buksan ang <code>chrome://extensions</code> at pindutin ang <b>I-reload</b> sa Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Kinukuha ang $1…"
+ },
+ "createdIn": {
+ "message": "Nalikha ang $1 ($2) sa $3"
+ },
+ "intoFolder": {
+ "message": "sa $1"
+ },
+ "helpWhatTitle": {
+ "message": "Ang ginagawa ng Bento Tray"
+ },
+ "helpWhatSub": {
+ "message": "Ang dokumentong Bento ay iisang HTML file na dala ang sarili nitong editor. Kapag binuksan mismo mula sa disk, hindi ito pinapayagan ng browser na magsulat pabalik sa sarili nito — kaya't tinatanong ka ng bawat pag-save kung saan ilalagay. Ang Bento Tray ang nag-aalis ng tanong na iyon."
+ },
+ "tourSaveTitle": {
+ "message": "I-save sa mismong file"
+ },
+ "tourSaveBody": {
+ "message": "Direktang isinusulat ng ⌘S pabalik sa file na binuksan mo, walang dialog. Ganoon din ang daan ng autosave at ng mga update sa mismong file."
+ },
+ "tourFindTitle": {
+ "message": "Hanapin ang mga dokumento mo"
+ },
+ "tourFindBody": {
+ "message": "Bawat dokumentong Bento sa mga folder mo, kasama ang tunay nitong pamagat at larawan ng unang pahina. Saklaw ng paghahanap ang nakasulat sa loob nila."
+ },
+ "tourSwitchTitle": {
+ "message": "Maglipat habang nagtatrabaho"
+ },
+ "tourSwitchBody": {
+ "message": "Pindutin ang <kbd>Alt</kbd>+<kbd>B</kbd>, o mag-right-click sa loob ng isang dokumento, para sa panel sa tabi nito."
+ },
+ "tourNewTitle": {
+ "message": "Gumawa ng bago"
+ },
+ "tourNewBody": {
+ "message": "Kinukuha ng <b>+ Bagong dokumento</b> ang kasalukuyang release ng Slides, Spaces, o Dash at naglalagay ng bagong dokumento sa folder mo."
+ },
+ "helpNeedsTitle": {
+ "message": "Ang kailangan nito sa iyo"
+ },
+ "helpNeedsSub": {
+ "message": "Dalawang bagay, at pareho nilang wala sa kapangyarihan ng extension na ito na ayusin."
+ },
+ "helpFolder": {
+ "message": "Isang folder"
+ },
+ "helpFolderGranted": {
+ "message": "$1 ang pinahintulutan — nase-save sa mismong file ang mga dokumento sa loob"
+ },
+ "helpFolderNone": {
+ "message": "Hindi pa napipili. Saklaw ng isang malawak na folder ang lahat ng nasa loob nito."
+ },
+ "helpAccessOff": {
+ "message": "Naka-off. I-on ang <b>Payagan ang access sa mga file URL</b> sa <code>chrome://extensions</code> — walang extension ang makapag-o-on nito para sa sarili nito."
+ },
+ "helpAccessUnknown": {
+ "message": "Hindi ito iniuulat ng browser na ito. Kung nagtatanong pa rin ang pag-save, tingnan ito sa <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Naka-on — nababasa ng Bento Tray ang mga pahinang binuksan mo mula sa disk."
+ },
+ "helpNeverTitle": {
+ "message": "Ang hindi nito kailanman ginagawa"
+ },
+ "helpNeverSub": {
+ "message": "Nagbabasa at nagsusulat lang ito sa loob ng mga folder sa itaas, at sa file lang na talagang pinagbuksan ng isang pahina — ang browser ang nagsasabi kung alin, kaya't hindi maaaring pangalanan ng isang dokumento ang file ng iba. Walang anuman tungkol sa mga dokumento mo ang ina-upload kahit saan, at walang server ang extension na mapag-a-upload-an ng mga ito."
+ },
+ "helpAboutTitle": {
+ "message": "Tungkol"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · bahagi ng proyektong Bento · lisensyadong MIT"
+ },
+ "linkSource": {
+ "message": "Source sa GitHub"
+ },
+ "linkIssues": {
+ "message": "Mag-ulat ng problema"
+ },
+ "linkReleases": {
+ "message": "Mga release"
+ },
+ "primeMiddle": {
+ "message": "ang nananatili"
+ },
+ "primeNote": {
+ "message": "Gumagana rin ang dalawa pa, pero magtatanong muli ang Chrome — sa bawat restart para sa una, at pagkatapos ng paghihintay para sa huli."
+ }
+}
diff --git a/tray/webext/_locales/fr/messages.json b/tray/webext/_locales/fr/messages.json
new file mode 100644
index 00000000..2e0840b0
--- /dev/null
+++ b/tray/webext/_locales/fr/messages.json
@@ -0,0 +1,446 @@
+{
+ "appDesc": {
+ "message": "Enregistre un document Bento dans le fichier que vous avez ouvert, sans vous demander où.",
+ "description": "Chrome Web Store listing description. 132 characters maximum — the store truncates."
+ },
+ "navAll": {
+ "message": "Tous les documents"
+ },
+ "navFolders": {
+ "message": "Dossiers"
+ },
+ "navHelp": {
+ "message": "Aide et à propos"
+ },
+ "navSettings": {
+ "message": "Réglages"
+ },
+ "addFolder": {
+ "message": "+ Ajouter un dossier…"
+ },
+ "searchDocs": {
+ "message": "Rechercher des documents"
+ },
+ "searchDocsSlash": {
+ "message": "Rechercher des documents /"
+ },
+ "sortTitle": {
+ "message": "Trier"
+ },
+ "sortRecent": {
+ "message": "Modifiés récemment"
+ },
+ "sortName": {
+ "message": "Nom"
+ },
+ "sortFolder": {
+ "message": "Dossier"
+ },
+ "newDocument": {
+ "message": "+ Nouveau document"
+ },
+ "browseAll": {
+ "message": "Tout parcourir"
+ },
+ "reconnectFolders": {
+ "message": "Reconnecter les dossiers"
+ },
+ "primeIntro": {
+ "message": "Chrome va demander. Choisissez l’option du milieu :"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — un dossier doit être reconnecté",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray doit être reconnecté",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome a retiré l’autorisation d’un dossier. Tant qu’elle n’est pas rétablie, l’enregistrement demandera où mettre le document.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnect": {
+ "message": "Reconnecter"
+ },
+ "ctxOpenPanel": {
+ "message": "Ouvrir le panneau Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "Aucun document Bento dans vos dossiers pour l’instant."
+ },
+ "noMatches": {
+ "message": "Rien ne correspond à « $1 »"
+ },
+ "rowUnplacedTip": {
+ "message": "Ouvrez une fois un document de $1 depuis le Finder, et tout ce dossier s’ouvrira d’ici."
+ },
+ "encrypted": {
+ "message": "Protégé par mot de passe"
+ },
+ "notSavedYet": {
+ "message": "Pas encore enregistré"
+ },
+ "fileAccessOffShort": {
+ "message": "L’accès aux fichiers locaux est désactivé",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noFoldersYet": {
+ "message": "Aucun dossier pour l’instant"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 dossier doit être reconnecté",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "statusOneFolder": {
+ "message": "$1 dossier · enregistre sur place"
+ },
+ "statusFolders": {
+ "message": "$1 dossiers · enregistre sur place"
+ },
+ "renewNotOffered": {
+ "message": "Chrome n’a pas proposé de le restaurer",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "renewTryAfterRestart": {
+ "message": "Réessayez après avoir redémarré Chrome",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "fetchingLatest": {
+ "message": "Téléchargement du dernier Bento…"
+ },
+ "created": {
+ "message": "$1 créé"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 peut être lu, mais pas encore ouvert : Chrome n’indique pas à une extension où se trouve un dossier sur le disque. <b>Tout parcourir</b> les trouve en un clic.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "andMore": {
+ "message": " et $1 de plus"
+ },
+ "agoJustNow": {
+ "message": "à l’instant"
+ },
+ "agoMinutes": {
+ "message": "il y a $1 min"
+ },
+ "agoHour": {
+ "message": "il y a $1 heure"
+ },
+ "agoHours": {
+ "message": "il y a $1 heures"
+ },
+ "agoDay": {
+ "message": "il y a $1 jour"
+ },
+ "agoDays": {
+ "message": "il y a $1 jours"
+ },
+ "searchScope": {
+ "message": "La recherche porte sur les titres, les noms de fichier, les dossiers et le texte des documents."
+ },
+ "folderEmpty": {
+ "message": "Rien dans ce dossier pour l’instant"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Nouveau document</b> en met un ici."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray ne sait pas encore où se trouve $1 sur le disque. Utilisez « Trouver mes dossiers », ou ouvrez une fois un document depuis le Finder.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "cardRenamedTip": {
+ "message": "$1 est un document Bento sous un autre nom. Il s’ouvre d’ici, mais l’enregistrement demandera où le mettre — l’enregistrement sur place ne reconnaît que les fichiers en .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Nommé .html plutôt que .bento.html — il s’ouvre d’ici, mais l’enregistrement demandera où le mettre."
+ },
+ "menuOpen": {
+ "message": "Ouvrir"
+ },
+ "menuDuplicate": {
+ "message": "Dupliquer"
+ },
+ "menuRename": {
+ "message": "Renommer…"
+ },
+ "menuCopyPath": {
+ "message": "Copier le chemin"
+ },
+ "duplicatedAs": {
+ "message": "Dupliqué sous $1"
+ },
+ "renamePrompt": {
+ "message": "Renommer le document"
+ },
+ "renamedTo": {
+ "message": "Renommé en $1"
+ },
+ "pathCopied": {
+ "message": "Chemin copié"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — pas encore ouvert"
+ },
+ "setupTitle": {
+ "message": "Deux choses et c’est prêt"
+ },
+ "setupLead": {
+ "message": "Ensuite, ⌘S sur un document ouvert par double-clic écrit directement dans le fichier — sans jamais demander où."
+ },
+ "chooseFolder": {
+ "message": "Choisir un dossier…"
+ },
+ "setupStep1": {
+ "message": "Choisissez le dossier où vivent vos documents"
+ },
+ "setupStep1Note": {
+ "message": "Un dossier large suffit en général — il couvre tout ce qu’il contient."
+ },
+ "setupStep2": {
+ "message": "Activez l’accès aux fichiers locaux",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupStep2Note": {
+ "message": "Dans <code>chrome://extensions</code> → Bento Tray → <b>Autoriser l’accès aux URL de fichier</b>. Chrome ne laisse pas une extension l’activer elle-même.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Vous avez mis à jour et vos dossiers ont disparu ?</b> Une extension décompressée est identifiée par le chemin de son dossier : charger une nouvelle copie depuis un autre dossier en fait une autre extension. Vos dossiers restent accordés à l’ancienne. Remplacez plutôt les fichiers dans le dossier d’origine et appuyez sur <b>Actualiser</b> dans <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>L’accès aux fichiers locaux est désactivé</b> — rien ne s’enregistre sur place tant qu’il ne l’est pas. Activez <b>Autoriser l’accès aux URL de fichier</b> dans <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 dossier doit être reconnecté.</b> Reconnectez-le dans les <b>Réglages</b> et choisissez l’option du milieu — la seule qui dure.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> peut être listé mais pas encore ouvert — Chrome n’indique jamais à une extension où se trouve un dossier sur le disque.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "findFolders": {
+ "message": "Trouver mes dossiers"
+ },
+ "looking": {
+ "message": "Recherche…"
+ },
+ "findDeclined": {
+ "message": "<b>Pas de souci.</b> Ouvrez plutôt une fois un document de $1 depuis le Finder — cette page s’en apercevra."
+ },
+ "foundFolder": {
+ "message": "$1 dossier trouvé"
+ },
+ "foundFolders": {
+ "message": "$1 dossiers trouvés"
+ },
+ "foundNothing": {
+ "message": "Rien dans l’historique — ouvrez un document depuis le Finder"
+ },
+ "setFoldersSub": {
+ "message": "Les documents qui s’y trouvent s’enregistrent directement dans leur fichier, sans demander où. Un dossier couvre tout ce qu’il contient."
+ },
+ "noneYet": {
+ "message": "Aucun pour l’instant."
+ },
+ "savesInPlace": {
+ "message": "enregistre sur place"
+ },
+ "needsReconnecting": {
+ "message": "doit être reconnecté",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnectTip": {
+ "message": "Chrome demandera à restaurer ce dossier. Refuser le retire, et Chrome attend ensuite au moins un redémarrage avant de le reproposer.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "remove": {
+ "message": "Retirer"
+ },
+ "removeTip": {
+ "message": "Retire l’accès. Chrome peut encore se souvenir de l’autorisation, donc rajouter le dossier ne redemandera peut-être pas.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessTitle": {
+ "message": "Accès aux fichiers locaux",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessSub": {
+ "message": "Chrome ne laisse pas une extension activer cela elle-même, et rien ne fonctionne sans.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "stateOn": {
+ "message": "Activé"
+ },
+ "stateOff": {
+ "message": "Désactivé"
+ },
+ "stateUnknown": {
+ "message": "Inconnu"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray peut lire les pages que vous avez ouvertes depuis le disque.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessOffNote": {
+ "message": "Ouvrez chrome://extensions, trouvez Bento Tray et activez « Autoriser l’accès aux URL de fichier ».",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessUnknownNote": {
+ "message": "Ce navigateur ne le signale pas. Si l’enregistrement demande encore, vérifiez dans chrome://extensions.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setVersionTitle": {
+ "message": "Version"
+ },
+ "setVersionUnpacked": {
+ "message": "Cette copie a été chargée décompressée, Chrome ne la mettra donc jamais à jour."
+ },
+ "setVersionStore": {
+ "message": "Installé depuis le store, donc mis à jour tout seul."
+ },
+ "versionAvailable": {
+ "message": "$1 est disponible"
+ },
+ "versionUpToDate": {
+ "message": "à jour lors de la dernière vérification"
+ },
+ "versionManaged": {
+ "message": "tenu à jour par le navigateur"
+ },
+ "getIt": {
+ "message": "Obtenir"
+ },
+ "checkNow": {
+ "message": "Vérifier maintenant"
+ },
+ "autoCheckPref": {
+ "message": "<b>Vérifier s’il existe une nouvelle version au démarrage du navigateur.</b><br>Une requête vers bento.page pour un fichier statique. Elle n’envoie aucun identifiant, aucun numéro de version et rien sur vos documents — la comparaison se fait ici. Désactivée, rien n’est jamais demandé ; <b>Vérifier maintenant</b> fonctionne toujours.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "expectedSha": {
+ "message": "SHA-256 attendu du zip : $1"
+ },
+ "setReachTitle": {
+ "message": "Ce à quoi elle peut accéder",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setReachSub": {
+ "message": "Uniquement les dossiers ci-dessus, et uniquement le fichier depuis lequel une page a été ouverte. Rien n’est envoyé et rien n’est lu ailleurs.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 est disponible.</b> Cette copie a été chargée décompressée, Chrome ne la mettra donc jamais à jour."
+ },
+ "updateStep1": {
+ "message": "Téléchargez-le depuis GitHub"
+ },
+ "updateStep2": {
+ "message": "Remplacez les fichiers <b>dans le dossier depuis lequel vous l’avez chargé</b> — le même dossier, sinon Chrome le traite comme une autre extension et vos dossiers accordés ne suivent pas",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateStep3": {
+ "message": "Ouvrez <code>chrome://extensions</code> et appuyez sur <b>Actualiser</b> sur Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Téléchargement de $1…"
+ },
+ "createdIn": {
+ "message": "$1 ($2) créé dans $3"
+ },
+ "intoFolder": {
+ "message": "dans $1"
+ },
+ "helpWhatTitle": {
+ "message": "Ce que fait Bento Tray"
+ },
+ "helpWhatSub": {
+ "message": "Un document Bento est un fichier HTML qui embarque son propre éditeur. Ouvert directement depuis le disque, un navigateur ne le laisse pas se réécrire — l’enregistrement demande donc à chaque fois où le mettre. Bento Tray supprime cette question."
+ },
+ "tourSaveTitle": {
+ "message": "Enregistrer sur place"
+ },
+ "tourSaveBody": {
+ "message": "⌘S écrit directement dans le fichier que vous avez ouvert, sans dialogue. L’enregistrement automatique et les mises à jour passent par le même chemin."
+ },
+ "tourFindTitle": {
+ "message": "Retrouvez vos documents"
+ },
+ "tourFindBody": {
+ "message": "Chaque document Bento de vos dossiers, avec son vrai titre et une image de sa première page. La recherche couvre ce qui est écrit dedans."
+ },
+ "tourSwitchTitle": {
+ "message": "Changer en cours de travail"
+ },
+ "tourSwitchBody": {
+ "message": "Appuyez sur <kbd>Alt</kbd>+<kbd>B</kbd>, ou faites un clic droit dans un document, pour un panneau à côté."
+ },
+ "tourNewTitle": {
+ "message": "Créez-en un"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Nouveau document</b> télécharge la version actuelle de Slides, Spaces ou Dash et met un document neuf dans votre dossier."
+ },
+ "helpNeedsTitle": {
+ "message": "Ce dont elle a besoin"
+ },
+ "helpNeedsSub": {
+ "message": "Deux choses, toutes deux hors du pouvoir de cette extension."
+ },
+ "helpFolder": {
+ "message": "Un dossier"
+ },
+ "helpFolderGranted": {
+ "message": "$1 accordés — les documents qu’ils contiennent s’enregistrent sur place"
+ },
+ "helpFolderNone": {
+ "message": "Pas encore choisi. Un dossier large couvre tout ce qu’il contient."
+ },
+ "helpAccessOff": {
+ "message": "Désactivé. Activez <b>Autoriser l’accès aux URL de fichier</b> dans <code>chrome://extensions</code> — aucune extension ne peut l’activer elle-même.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessUnknown": {
+ "message": "Ce navigateur ne le signale pas. Si l’enregistrement demande encore, vérifiez dans <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessOn": {
+ "message": "Activé — Bento Tray peut lire les pages que vous avez ouvertes depuis le disque.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverTitle": {
+ "message": "Ce qu’elle ne fait jamais",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverSub": {
+ "message": "Elle lit et écrit uniquement dans les dossiers ci-dessus, et uniquement le fichier depuis lequel une page a réellement été ouverte — le navigateur indique lequel, donc un document ne peut pas désigner le fichier d’un autre. Rien de vos documents n’est envoyé où que ce soit, et l’extension n’a aucun serveur pour cela.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAboutTitle": {
+ "message": "À propos"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · projet Bento · licence MIT"
+ },
+ "linkSource": {
+ "message": "Code sur GitHub"
+ },
+ "linkIssues": {
+ "message": "Signaler un problème"
+ },
+ "linkReleases": {
+ "message": "Versions"
+ },
+ "primeMiddle": {
+ "message": "celle qui dure"
+ },
+ "primeNote": {
+ "message": "Les deux autres fonctionnent aussi, mais Chrome redemandera — à chaque redémarrage pour la première, après une attente pour la dernière."
+ }
+}
diff --git a/tray/webext/_locales/he/messages.json b/tray/webext/_locales/he/messages.json
new file mode 100644
index 00000000..f12dbe56
--- /dev/null
+++ b/tray/webext/_locales/he/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "שמרו מסמך Bento בחזרה אל הקובץ שפתחתם, בלי שאלה על יעד."
+ },
+ "navAll": {
+ "message": "כל המסמכים"
+ },
+ "navFolders": {
+ "message": "תיקיות"
+ },
+ "navHelp": {
+ "message": "עזרה ואודות"
+ },
+ "navSettings": {
+ "message": "הגדרות"
+ },
+ "addFolder": {
+ "message": "+ הוספת תיקייה…"
+ },
+ "searchDocs": {
+ "message": "חיפוש במסמכים"
+ },
+ "searchDocsSlash": {
+ "message": "חיפוש במסמכים /"
+ },
+ "sortTitle": {
+ "message": "מיון"
+ },
+ "sortRecent": {
+ "message": "שונו לאחרונה"
+ },
+ "sortName": {
+ "message": "שם"
+ },
+ "sortFolder": {
+ "message": "תיקייה"
+ },
+ "newDocument": {
+ "message": "+ מסמך חדש"
+ },
+ "browseAll": {
+ "message": "עיון בהכול"
+ },
+ "reconnectFolders": {
+ "message": "חיבור מחדש של תיקיות"
+ },
+ "primeIntro": {
+ "message": "Chrome עומד לשאול. בחרו באפשרות האמצעית:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — תיקייה זקוקה לחיבור מחדש"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray זקוק לחיבור מחדש"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome ביטל את ההרשאה לתיקייה. עד שתשוחזר, כל שמירה תשאל אתכם היכן להניח את הקובץ."
+ },
+ "reconnect": {
+ "message": "חיבור מחדש"
+ },
+ "ctxOpenPanel": {
+ "message": "פתיחת החלונית של Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "אין עדיין מסמכי Bento בתיקיות שלכם."
+ },
+ "noMatches": {
+ "message": "שום דבר לא תואם ל„$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "פתחו פעם אחת מסמך כלשהו ב־$1 דרך Finder, וכל מה שבתיקייה ההיא ייפתח מכאן."
+ },
+ "encrypted": {
+ "message": "מוגן בסיסמה"
+ },
+ "notSavedYet": {
+ "message": "עדיין לא נשמר"
+ },
+ "fileAccessOffShort": {
+ "message": "הגישה לקבצים מקומיים כבויה"
+ },
+ "noFoldersYet": {
+ "message": "אין עדיין תיקיות"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 תיקיות זקוקות לחיבור מחדש"
+ },
+ "statusOneFolder": {
+ "message": "$1 תיקייה · שומרת במקום"
+ },
+ "statusFolders": {
+ "message": "$1 תיקיות · שומרות במקום"
+ },
+ "renewNotOffered": {
+ "message": "Chrome לא הציע לשחזר אותה"
+ },
+ "renewTryAfterRestart": {
+ "message": "נסו שוב לאחר הפעלה מחדש של Chrome"
+ },
+ "fetchingLatest": {
+ "message": "מוריד את Bento העדכני…"
+ },
+ "created": {
+ "message": "$1 נוצר"
+ },
+ "panelUnplaced": {
+ "message": "אפשר לקרוא את <b>$1</b>$2 אך עדיין לא לפתוח — Chrome אינו מגלה להרחבה היכן תיקייה נמצאת בדיסק. <b>עיון בהכול</b> מוצא אותם בלחיצה אחת."
+ },
+ "andMore": {
+ "message": " ועוד $1"
+ },
+ "agoJustNow": {
+ "message": "ממש עכשיו"
+ },
+ "agoMinutes": {
+ "message": "לפני $1 דק׳"
+ },
+ "agoHour": {
+ "message": "לפני $1 שעה"
+ },
+ "agoHours": {
+ "message": "לפני $1 שעות"
+ },
+ "agoDay": {
+ "message": "לפני $1 יום"
+ },
+ "agoDays": {
+ "message": "לפני $1 ימים"
+ },
+ "searchScope": {
+ "message": "החיפוש בוחן כותרות, שמות קבצים, תיקיות והמילים שבתוך המסמכים."
+ },
+ "folderEmpty": {
+ "message": "אין עדיין דבר בתיקייה הזאת"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ מסמך חדש</b> יניח כאן מסמך חדש."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray עדיין לא יודע היכן $1 נמצאת בדיסק. השתמשו ב„מצא את התיקיות שלי”, או פתחו פעם אחת דרך Finder מסמך כלשהו שבתוכה."
+ },
+ "cardRenamedTip": {
+ "message": "$1 הוא מסמך Bento תחת שם אחר. הוא נפתח מכאן, אך השמירה תשאל על יעד — שמירה במקום מזהה רק קבצים שמסתיימים ב־‎.bento.html."
+ },
+ "badgeRenamed": {
+ "message": "נקרא ‎.html במקום ‎.bento.html — נפתח מכאן, אך השמירה תשאל על יעד."
+ },
+ "menuOpen": {
+ "message": "פתיחה"
+ },
+ "menuDuplicate": {
+ "message": "שכפול"
+ },
+ "menuRename": {
+ "message": "שינוי שם…"
+ },
+ "menuCopyPath": {
+ "message": "העתקת נתיב"
+ },
+ "duplicatedAs": {
+ "message": "שוכפל בשם $1"
+ },
+ "renamePrompt": {
+ "message": "שינוי שם המסמך"
+ },
+ "renamedTo": {
+ "message": "השם שונה ל־$1"
+ },
+ "pathCopied": {
+ "message": "הנתיב הועתק"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — עדיין לא נפתחה"
+ },
+ "setupTitle": {
+ "message": "שני דברים ואתם מוכנים"
+ },
+ "setupLead": {
+ "message": "מכאן ואילך, ⌘S במסמך שפתחתם בלחיצה כפולה כותב היישר בחזרה אל הקובץ — בלי שאלה על יעד, לעולם."
+ },
+ "chooseFolder": {
+ "message": "בחירת תיקייה…"
+ },
+ "setupStep1": {
+ "message": "בחרו את התיקייה שבה נמצאים המסמכים שלכם"
+ },
+ "setupStep1Note": {
+ "message": "תיקייה רחבה אחת מספיקה בדרך כלל — היא מכסה את כל מה שבתוכה."
+ },
+ "setupStep2": {
+ "message": "הפעילו גישה לקבצים מקומיים"
+ },
+ "setupStep2Note": {
+ "message": "ב־<code>chrome://extensions</code> ← Bento Tray ← <b>אפשר גישה לכתובות של קבצים</b>. Chrome אינו מרשה להרחבה להפעיל זאת בעצמה."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>שדרגתם וציפיתם שהתיקיות שלכם יהיו כאן?</b> הרחבה לא ארוזה מזוהה לפי נתיב התיקייה שלה, ולכן עותק חדש שנטען מתיקייה אחרת הוא הרחבה אחרת. התיקיות שלכם עדיין מוקצות לישנה. במקום זאת החליפו את הקבצים בתיקייה המקורית ולחצו <b>טען מחדש</b> ב־<code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>הגישה לקבצים מקומיים כבויה</b> — שום דבר לא יישמר במקום עד שתופעל. הפעילו <b>אפשר גישה לכתובות של קבצים</b> ב־<code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 תיקיות זקוקות לחיבור מחדש.</b> חברו אותן מחדש ב<b>הגדרות</b>, ובחרו <b>אפשר בכל ביקור</b> — האפשרות היחידה שמחזיקה מעמד."
+ },
+ "noticeUnplaced": {
+ "message": "אפשר להציג את <b>$1</b> ברשימה אך עדיין לא לפתוח — Chrome לעולם אינו מגלה להרחבה היכן תיקייה נמצאת בדיסק."
+ },
+ "findFolders": {
+ "message": "מצא את התיקיות שלי"
+ },
+ "looking": {
+ "message": "מחפש…"
+ },
+ "findDeclined": {
+ "message": "<b>אין בעיה.</b> במקום זאת פתחו פעם אחת דרך Finder מסמך כלשהו ב־$1 — הדף הזה יבחין בכך."
+ },
+ "foundFolder": {
+ "message": "נמצאה $1 תיקייה"
+ },
+ "foundFolders": {
+ "message": "נמצאו $1 תיקיות"
+ },
+ "foundNothing": {
+ "message": "אין עדיין דבר בהיסטוריה — פתחו מסמך אחד דרך Finder"
+ },
+ "setFoldersSub": {
+ "message": "מסמכים שבתוכן נשמרים היישר בחזרה אל הקובץ, בלי שאלה על יעד. תיקייה מכסה את כל מה שבתוכה."
+ },
+ "noneYet": {
+ "message": "אין עדיין."
+ },
+ "savesInPlace": {
+ "message": "שומרת במקום"
+ },
+ "needsReconnecting": {
+ "message": "זקוקה לחיבור מחדש"
+ },
+ "reconnectTip": {
+ "message": "Chrome יבקש רשות לשחזר את התיקייה הזאת. „אל תאפשר” מוותר עליה, ולאחר מכן Chrome ממתין לפחות להפעלה מחדש לפני שישאל שוב."
+ },
+ "remove": {
+ "message": "הסרה"
+ },
+ "removeTip": {
+ "message": "שוללת את הגישה. ייתכן ש־Chrome עדיין יזכור את ההרשאה, ולכן הוספה מחדש של התיקייה עשויה לא לשאול שוב."
+ },
+ "setAccessTitle": {
+ "message": "גישה לקבצים מקומיים"
+ },
+ "setAccessSub": {
+ "message": "Chrome אינו מרשה להרחבה להפעיל זאת בעצמה, ובלי זה שום דבר לא עובד."
+ },
+ "stateOn": {
+ "message": "מופעל"
+ },
+ "stateOff": {
+ "message": "כבוי"
+ },
+ "stateUnknown": {
+ "message": "לא ידוע"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray יכול לקרוא דפים שפתחתם מהדיסק."
+ },
+ "accessOffNote": {
+ "message": "פתחו את chrome://extensions, מצאו את Bento Tray והפעילו „אפשר גישה לכתובות של קבצים”."
+ },
+ "accessUnknownNote": {
+ "message": "הדפדפן הזה אינו מדווח על כך. אם השמירה עדיין שואלת, בדקו זאת ב־chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "גרסה"
+ },
+ "setVersionUnpacked": {
+ "message": "העותק הזה נטען לא ארוז, ולכן Chrome לעולם לא יעדכן אותו."
+ },
+ "setVersionStore": {
+ "message": "הותקן מהחנות, ולכן הוא מתעדכן בעצמו."
+ },
+ "versionAvailable": {
+ "message": "$1 זמינה"
+ },
+ "versionUpToDate": {
+ "message": "עדכנית נכון לבדיקה האחרונה"
+ },
+ "versionManaged": {
+ "message": "הדפדפן שומר עליה עדכנית"
+ },
+ "getIt": {
+ "message": "הורדה"
+ },
+ "checkNow": {
+ "message": "בדוק עכשיו"
+ },
+ "autoCheckPref": {
+ "message": "<b>בדוק אם יש גרסה חדשה בעת הפעלת הדפדפן.</b><br>בקשה אחת אל bento.page עבור קובץ סטטי. היא אינה שולחת מזהים, אינה שולחת מספר גרסה ואינה שולחת דבר על המסמכים שלכם — ההשוואה מתבצעת כאן. כבו אותה ושום דבר לא יתבקש לעולם; <b>בדוק עכשיו</b> ימשיך לעבוד."
+ },
+ "expectedSha": {
+ "message": "ערך SHA-256 הצפוי של קובץ ה־zip: $1"
+ },
+ "setReachTitle": {
+ "message": "עד לאן זה מגיע"
+ },
+ "setReachSub": {
+ "message": "רק התיקיות שלמעלה, ורק הקובץ שממנו דף אכן נפתח. שום דבר אינו מועלה ושום דבר אינו נקרא בשום מקום אחר."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 זמינה.</b> העותק הזה נטען לא ארוז, ולכן Chrome לעולם לא יעדכן אותו."
+ },
+ "updateStep1": {
+ "message": "הורידו אותה מ־GitHub"
+ },
+ "updateStep2": {
+ "message": "החליפו את הקבצים <b>בתיקייה שממנה טענתם אותה</b> — אותה תיקייה, אחרת Chrome יראה בה הרחבה אחרת והתיקיות שהרשיתם לא יבואו איתה"
+ },
+ "updateStep3": {
+ "message": "פתחו את <code>chrome://extensions</code> ולחצו <b>טען מחדש</b> על Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "מוריד את $1…"
+ },
+ "createdIn": {
+ "message": "נוצר $1 ($2) ב־$3"
+ },
+ "intoFolder": {
+ "message": "אל $1"
+ },
+ "helpWhatTitle": {
+ "message": "מה Bento Tray עושה"
+ },
+ "helpWhatSub": {
+ "message": "מסמך Bento הוא קובץ HTML יחיד שנושא את העורך שלו עמו. כשהוא נפתח היישר מהדיסק, הדפדפן אינו מרשה לו לכתוב בחזרה אל עצמו — ולכן כל שמירה שואלת היכן להניח אותו. Bento Tray הוא מה שמסלק את השאלה הזאת."
+ },
+ "tourSaveTitle": {
+ "message": "שמירה במקום"
+ },
+ "tourSaveBody": {
+ "message": "⌘S כותב היישר בחזרה אל הקובץ שפתחתם, בלי חלון דו־שיח. שמירה אוטומטית ועדכונים במקום הולכים באותה דרך."
+ },
+ "tourFindTitle": {
+ "message": "מצאו את המסמכים שלכם"
+ },
+ "tourFindBody": {
+ "message": "כל מסמך Bento בתיקיות שלכם, עם הכותרת האמיתית שלו ותמונה של העמוד הראשון. החיפוש מקיף גם את מה שכתוב בתוכם."
+ },
+ "tourSwitchTitle": {
+ "message": "החליפו תוך כדי עבודה"
+ },
+ "tourSwitchBody": {
+ "message": "הקישו <kbd>Alt</kbd>+<kbd>B</kbd>, או לחצו לחיצה ימנית בתוך מסמך, לקבלת חלונית לצדו."
+ },
+ "tourNewTitle": {
+ "message": "צרו מסמך חדש"
+ },
+ "tourNewBody": {
+ "message": "<b>+ מסמך חדש</b> מוריד את המהדורה הנוכחית של Slides, Spaces או Dash ומניח מסמך חדש בתיקייה שלכם."
+ },
+ "helpNeedsTitle": {
+ "message": "מה הוא צריך מכם"
+ },
+ "helpNeedsSub": {
+ "message": "שני דברים, ושניהם מחוץ ליכולתה של ההרחבה הזאת לסדר."
+ },
+ "helpFolder": {
+ "message": "תיקייה"
+ },
+ "helpFolderGranted": {
+ "message": "$1 הורשו — מסמכים שבתוכן נשמרים במקום"
+ },
+ "helpFolderNone": {
+ "message": "עדיין לא נבחרה. תיקייה רחבה אחת מכסה את כל מה שבתוכה."
+ },
+ "helpAccessOff": {
+ "message": "כבוי. הפעילו <b>אפשר גישה לכתובות של קבצים</b> ב־<code>chrome://extensions</code> — שום הרחבה אינה יכולה להפעיל זאת בעצמה."
+ },
+ "helpAccessUnknown": {
+ "message": "הדפדפן הזה אינו מדווח על כך. אם השמירה עדיין שואלת, בדקו זאת ב־<code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "מופעל — Bento Tray יכול לקרוא דפים שפתחתם מהדיסק."
+ },
+ "helpNeverTitle": {
+ "message": "מה הוא לעולם אינו עושה"
+ },
+ "helpNeverSub": {
+ "message": "הוא קורא וכותב רק בתוך התיקיות שלמעלה, ורק את הקובץ שממנו דף אכן נפתח — הדפדפן מוסר איזה, כך שמסמך אינו יכול לנקוב בקובץ של מישהו אחר. שום דבר על המסמכים שלכם אינו מועלה לשום מקום, ולהרחבה אין בכלל שרת להעלות אליו."
+ },
+ "helpAboutTitle": {
+ "message": "אודות"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · חלק מפרויקט Bento · ברישיון MIT"
+ },
+ "linkSource": {
+ "message": "קוד המקור ב־GitHub"
+ },
+ "linkIssues": {
+ "message": "דיווח על תקלה"
+ },
+ "linkReleases": {
+ "message": "מהדורות"
+ },
+ "primeMiddle": {
+ "message": "זו שמחזיקה מעמד"
+ },
+ "primeNote": {
+ "message": "גם השתיים האחרות עובדות, אך Chrome ישאל שוב — בכל הפעלה מחדש עבור הראשונה, ולאחר המתנה עבור האחרונה."
+ }
+}
diff --git a/tray/webext/_locales/hi/messages.json b/tray/webext/_locales/hi/messages.json
new file mode 100644
index 00000000..bd07c90a
--- /dev/null
+++ b/tray/webext/_locales/hi/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "किसी Bento दस्तावेज़ को उसी फ़ाइल में वापस सहेजें जिसे आपने खोला था, बिना जगह पूछे।"
+ },
+ "navAll": {
+ "message": "सभी दस्तावेज़"
+ },
+ "navFolders": {
+ "message": "फ़ोल्डर"
+ },
+ "navHelp": {
+ "message": "मदद और परिचय"
+ },
+ "navSettings": {
+ "message": "सेटिंग"
+ },
+ "addFolder": {
+ "message": "+ फ़ोल्डर जोड़ें…"
+ },
+ "searchDocs": {
+ "message": "दस्तावेज़ खोजें"
+ },
+ "searchDocsSlash": {
+ "message": "दस्तावेज़ खोजें /"
+ },
+ "sortTitle": {
+ "message": "क्रमबद्ध करें"
+ },
+ "sortRecent": {
+ "message": "हाल में बदले गए"
+ },
+ "sortName": {
+ "message": "नाम"
+ },
+ "sortFolder": {
+ "message": "फ़ोल्डर"
+ },
+ "newDocument": {
+ "message": "+ नया दस्तावेज़"
+ },
+ "browseAll": {
+ "message": "सभी देखें"
+ },
+ "reconnectFolders": {
+ "message": "फ़ोल्डर फिर से जोड़ें"
+ },
+ "primeIntro": {
+ "message": "Chrome अभी पूछेगा। बीच वाला विकल्प चुनें:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — एक फ़ोल्डर को फिर से जोड़ना है"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray को फिर से जोड़ना है"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome ने एक फ़ोल्डर की अनुमति वापस ले ली। जब तक वह बहाल नहीं होती, हर बार सहेजने पर पूछा जाएगा कि फ़ाइल कहाँ रखनी है।"
+ },
+ "reconnect": {
+ "message": "फिर से जोड़ें"
+ },
+ "ctxOpenPanel": {
+ "message": "Bento Tray पैनल खोलें"
+ },
+ "panelEmpty": {
+ "message": "आपके फ़ोल्डरों में अभी कोई Bento दस्तावेज़ नहीं है।"
+ },
+ "noMatches": {
+ "message": "“$1” से कुछ भी मेल नहीं खाता"
+ },
+ "rowUnplacedTip": {
+ "message": "$1 का कोई एक दस्तावेज़ Finder से एक बार खोल लें, फिर उस फ़ोल्डर की हर चीज़ यहीं से खुलने लगेगी।"
+ },
+ "encrypted": {
+ "message": "पासवर्ड से सुरक्षित"
+ },
+ "notSavedYet": {
+ "message": "अभी सहेजा नहीं गया"
+ },
+ "fileAccessOffShort": {
+ "message": "स्थानीय फ़ाइल पहुँच बंद है"
+ },
+ "noFoldersYet": {
+ "message": "अभी कोई फ़ोल्डर नहीं"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 फ़ोल्डर को फिर से जोड़ना है"
+ },
+ "statusOneFolder": {
+ "message": "$1 फ़ोल्डर · वहीं पर सहेजता है"
+ },
+ "statusFolders": {
+ "message": "$1 फ़ोल्डर · वहीं पर सहेजते हैं"
+ },
+ "renewNotOffered": {
+ "message": "Chrome ने उसे बहाल करने की पेशकश नहीं की"
+ },
+ "renewTryAfterRestart": {
+ "message": "Chrome को फिर से चालू करके दोबारा कोशिश करें"
+ },
+ "fetchingLatest": {
+ "message": "नवीनतम Bento लाया जा रहा है…"
+ },
+ "created": {
+ "message": "$1 बनाया गया"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 पढ़ा तो जा सकता है पर अभी खोला नहीं जा सकता — Chrome किसी एक्सटेंशन को यह नहीं बताता कि फ़ोल्डर डिस्क पर कहाँ है। <b>सभी देखें</b> उन्हें एक ही क्लिक में ढूँढ़ लेता है।"
+ },
+ "andMore": {
+ "message": " और $1 अन्य"
+ },
+ "agoJustNow": {
+ "message": "अभी-अभी"
+ },
+ "agoMinutes": {
+ "message": "$1 मिनट पहले"
+ },
+ "agoHour": {
+ "message": "$1 घंटा पहले"
+ },
+ "agoHours": {
+ "message": "$1 घंटे पहले"
+ },
+ "agoDay": {
+ "message": "$1 दिन पहले"
+ },
+ "agoDays": {
+ "message": "$1 दिन पहले"
+ },
+ "searchScope": {
+ "message": "खोज शीर्षक, फ़ाइल नाम, फ़ोल्डर और दस्तावेज़ों के भीतर के शब्दों को देखती है।"
+ },
+ "folderEmpty": {
+ "message": "इस फ़ोल्डर में अभी कुछ नहीं है"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ नया दस्तावेज़</b> यहाँ एक नया रख देता है।"
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray को अभी नहीं पता कि $1 डिस्क पर कहाँ है। “मेरे फ़ोल्डर ढूँढ़ें” का उपयोग करें, या उसमें का कोई दस्तावेज़ Finder से एक बार खोलें।"
+ },
+ "cardRenamedTip": {
+ "message": "$1 दूसरे नाम वाला एक Bento दस्तावेज़ है। यह यहीं से खुलता है, पर सहेजने पर जगह पूछी जाएगी — वहीं पर सहेजना केवल .bento.html से समाप्त होने वाली फ़ाइलों को पहचानता है।"
+ },
+ "badgeRenamed": {
+ "message": ".bento.html के बजाय .html नाम है — यह यहीं से खुलता है, पर सहेजने पर जगह पूछी जाएगी।"
+ },
+ "menuOpen": {
+ "message": "खोलें"
+ },
+ "menuDuplicate": {
+ "message": "प्रतिलिपि बनाएँ"
+ },
+ "menuRename": {
+ "message": "नाम बदलें…"
+ },
+ "menuCopyPath": {
+ "message": "पथ कॉपी करें"
+ },
+ "duplicatedAs": {
+ "message": "$1 के रूप में प्रतिलिपि बनी"
+ },
+ "renamePrompt": {
+ "message": "दस्तावेज़ का नाम बदलें"
+ },
+ "renamedTo": {
+ "message": "नाम बदलकर $1 किया गया"
+ },
+ "pathCopied": {
+ "message": "पथ कॉपी हो गया"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — अभी खोला नहीं गया"
+ },
+ "setupTitle": {
+ "message": "दो काम और आप तैयार"
+ },
+ "setupLead": {
+ "message": "इसके बाद, डबल-क्लिक से खोले गए दस्तावेज़ में ⌘S सीधे उसी फ़ाइल में लिखता है — जगह कभी नहीं पूछी जाएगी।"
+ },
+ "chooseFolder": {
+ "message": "फ़ोल्डर चुनें…"
+ },
+ "setupStep1": {
+ "message": "वह फ़ोल्डर चुनें जिसमें आपके दस्तावेज़ रहते हैं"
+ },
+ "setupStep1Note": {
+ "message": "आमतौर पर एक बड़ा फ़ोल्डर काफ़ी है — उसके भीतर की हर चीज़ इसमें आ जाती है।"
+ },
+ "setupStep2": {
+ "message": "स्थानीय फ़ाइल पहुँच चालू करें"
+ },
+ "setupStep2Note": {
+ "message": "<code>chrome://extensions</code> → Bento Tray → <b>फ़ाइल URL तक पहुँच की अनुमति दें</b>। Chrome किसी एक्सटेंशन को इसे स्वयं चालू करने नहीं देता।"
+ },
+ "setupUpgradeNote": {
+ "message": "<b>अपग्रेड किया और सोचा कि आपके फ़ोल्डर यहीं होंगे?</b> अनपैक्ड एक्सटेंशन उसके फ़ोल्डर पथ से पहचाना जाता है, इसलिए किसी दूसरे फ़ोल्डर से लोड की गई नई प्रति एक अलग एक्सटेंशन है। आपके फ़ोल्डर अब भी पुराने वाले से जुड़े हैं। इसके बजाय मूल फ़ोल्डर की फ़ाइलें बदलें और <code>chrome://extensions</code> में <b>पुनः लोड करें</b> दबाएँ।"
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>स्थानीय फ़ाइल पहुँच बंद है</b> — जब तक यह चालू नहीं होती, कुछ भी वहीं पर नहीं सहेजा जाएगा। <code>chrome://extensions</code> में <b>फ़ाइल URL तक पहुँच की अनुमति दें</b> चालू करें।"
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 फ़ोल्डर को फिर से जोड़ना है।</b> <b>सेटिंग</b> में उसे फिर से जोड़ें और <b>हर बार अनुमति दें</b> चुनें — यही एकमात्र विकल्प है जो टिकता है।"
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> सूची में दिख तो सकता है पर अभी खोला नहीं जा सकता — Chrome किसी एक्सटेंशन को कभी नहीं बताता कि फ़ोल्डर डिस्क पर कहाँ है।"
+ },
+ "findFolders": {
+ "message": "मेरे फ़ोल्डर ढूँढ़ें"
+ },
+ "looking": {
+ "message": "खोजा जा रहा है…"
+ },
+ "findDeclined": {
+ "message": "<b>कोई बात नहीं।</b> इसके बजाय $1 का कोई दस्तावेज़ Finder से एक बार खोल लें — यह पेज भाँप लेगा।"
+ },
+ "foundFolder": {
+ "message": "$1 फ़ोल्डर मिला"
+ },
+ "foundFolders": {
+ "message": "$1 फ़ोल्डर मिले"
+ },
+ "foundNothing": {
+ "message": "इतिहास में अभी कुछ नहीं — Finder से एक दस्तावेज़ खोलें"
+ },
+ "setFoldersSub": {
+ "message": "इनमें रखे दस्तावेज़ सीधे उसी फ़ाइल में सहेजे जाते हैं, जगह पूछे बिना। एक फ़ोल्डर उसके भीतर की हर चीज़ को समेटता है।"
+ },
+ "noneYet": {
+ "message": "अभी कोई नहीं।"
+ },
+ "savesInPlace": {
+ "message": "वहीं पर सहेजता है"
+ },
+ "needsReconnecting": {
+ "message": "फिर से जोड़ना है"
+ },
+ "reconnectTip": {
+ "message": "Chrome इस फ़ोल्डर को बहाल करने के लिए पूछेगा। “अनुमति न दें” उसे छोड़ देता है, और उसके बाद Chrome दोबारा पूछने से पहले कम से कम एक बार पुनःआरंभ की प्रतीक्षा करता है।"
+ },
+ "remove": {
+ "message": "हटाएँ"
+ },
+ "removeTip": {
+ "message": "पहुँच वापस ले लेता है। Chrome अनुमति याद रख सकता है, इसलिए फ़ोल्डर दोबारा जोड़ने पर शायद कुछ न पूछा जाए।"
+ },
+ "setAccessTitle": {
+ "message": "स्थानीय फ़ाइल पहुँच"
+ },
+ "setAccessSub": {
+ "message": "Chrome किसी एक्सटेंशन को इसे स्वयं चालू करने नहीं देता, और इसके बिना कुछ भी काम नहीं करता।"
+ },
+ "stateOn": {
+ "message": "चालू"
+ },
+ "stateOff": {
+ "message": "बंद"
+ },
+ "stateUnknown": {
+ "message": "अज्ञात"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray डिस्क से खोले गए पेज पढ़ सकता है।"
+ },
+ "accessOffNote": {
+ "message": "chrome://extensions खोलें, Bento Tray ढूँढ़ें, “फ़ाइल URL तक पहुँच की अनुमति दें” चालू करें।"
+ },
+ "accessUnknownNote": {
+ "message": "यह ब्राउज़र इसकी जानकारी नहीं देता। यदि सहेजने पर अब भी पूछा जाए, तो chrome://extensions में देखें।"
+ },
+ "setVersionTitle": {
+ "message": "संस्करण"
+ },
+ "setVersionUnpacked": {
+ "message": "यह प्रति अनपैक्ड रूप में लोड की गई थी, इसलिए Chrome इसे कभी अपडेट नहीं करेगा।"
+ },
+ "setVersionStore": {
+ "message": "स्टोर से इंस्टॉल किया गया, इसलिए यह स्वयं अपडेट होता है।"
+ },
+ "versionAvailable": {
+ "message": "$1 उपलब्ध है"
+ },
+ "versionUpToDate": {
+ "message": "पिछली जाँच के अनुसार नवीनतम"
+ },
+ "versionManaged": {
+ "message": "ब्राउज़र इसे नवीनतम रखता है"
+ },
+ "getIt": {
+ "message": "प्राप्त करें"
+ },
+ "checkNow": {
+ "message": "अभी जाँचें"
+ },
+ "autoCheckPref": {
+ "message": "<b>ब्राउज़र शुरू होने पर नया संस्करण जाँचें।</b><br>एक स्थिर फ़ाइल के लिए bento.page को एक अनुरोध। यह न कोई पहचानकर्ता भेजता है, न संस्करण संख्या, और न आपके दस्तावेज़ों के बारे में कुछ — तुलना यहीं होती है। इसे बंद कर दें तो कभी कोई अनुरोध नहीं जाएगा; <b>अभी जाँचें</b> तब भी काम करता है।"
+ },
+ "expectedSha": {
+ "message": "zip का अपेक्षित SHA-256: $1"
+ },
+ "setReachTitle": {
+ "message": "यह कहाँ तक पहुँच सकता है"
+ },
+ "setReachSub": {
+ "message": "केवल ऊपर के फ़ोल्डर, और केवल वही फ़ाइल जिससे कोई पेज वास्तव में खोला गया था। कुछ भी अपलोड नहीं होता और कहीं और कुछ भी नहीं पढ़ा जाता।"
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 उपलब्ध है।</b> यह प्रति अनपैक्ड रूप में लोड की गई थी, इसलिए Chrome इसे कभी अपडेट नहीं करेगा।"
+ },
+ "updateStep1": {
+ "message": "इसे GitHub से डाउनलोड करें"
+ },
+ "updateStep2": {
+ "message": "फ़ाइलें <b>उसी फ़ोल्डर में</b> बदलें <b>जिससे आपने इसे लोड किया था</b> — वही फ़ोल्डर, वरना Chrome इसे अलग एक्सटेंशन मानेगा और दी गई अनुमतियों वाले फ़ोल्डर साथ नहीं आएँगे"
+ },
+ "updateStep3": {
+ "message": "<code>chrome://extensions</code> खोलें और Bento Tray पर <b>पुनः लोड करें</b> दबाएँ"
+ },
+ "fetchingApp": {
+ "message": "$1 लाया जा रहा है…"
+ },
+ "createdIn": {
+ "message": "$3 में $1 ($2) बनाया गया"
+ },
+ "intoFolder": {
+ "message": "$1 में"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray क्या करता है"
+ },
+ "helpWhatSub": {
+ "message": "एक Bento दस्तावेज़ एक ही HTML फ़ाइल है जो अपना संपादक साथ लिए चलती है। सीधे डिस्क से खोलने पर ब्राउज़र उसे स्वयं में वापस लिखने नहीं देता — इसलिए हर बार सहेजने पर पूछा जाता है कि कहाँ रखें। Bento Tray वही सवाल हटा देता है।"
+ },
+ "tourSaveTitle": {
+ "message": "वहीं पर सहेजें"
+ },
+ "tourSaveBody": {
+ "message": "⌘S बिना किसी डायलॉग के सीधे उसी फ़ाइल में लिखता है जिसे आपने खोला था। स्वतः सहेजना और वहीं पर होने वाले अपडेट भी उसी रास्ते जाते हैं।"
+ },
+ "tourFindTitle": {
+ "message": "अपने दस्तावेज़ ढूँढ़ें"
+ },
+ "tourFindBody": {
+ "message": "आपके फ़ोल्डरों का हर Bento दस्तावेज़, उसके असली शीर्षक और पहले पन्ने की तस्वीर के साथ। खोज उनके भीतर लिखी बातों तक जाती है।"
+ },
+ "tourSwitchTitle": {
+ "message": "काम करते-करते बदलें"
+ },
+ "tourSwitchBody": {
+ "message": "बगल में पैनल के लिए <kbd>Alt</kbd>+<kbd>B</kbd> दबाएँ, या दस्तावेज़ के भीतर दायाँ-क्लिक करें।"
+ },
+ "tourNewTitle": {
+ "message": "नया बनाएँ"
+ },
+ "tourNewBody": {
+ "message": "<b>+ नया दस्तावेज़</b> Slides, Spaces या Dash का मौजूदा रिलीज़ लाकर आपके फ़ोल्डर में एक नया दस्तावेज़ रख देता है।"
+ },
+ "helpNeedsTitle": {
+ "message": "इसे आपसे क्या चाहिए"
+ },
+ "helpNeedsSub": {
+ "message": "दो चीज़ें, और दोनों ही इस एक्सटेंशन के बस की नहीं हैं।"
+ },
+ "helpFolder": {
+ "message": "एक फ़ोल्डर"
+ },
+ "helpFolderGranted": {
+ "message": "$1 की अनुमति है — उनके भीतर के दस्तावेज़ वहीं पर सहेजे जाते हैं"
+ },
+ "helpFolderNone": {
+ "message": "अभी चुना नहीं गया। एक बड़ा फ़ोल्डर उसके भीतर की हर चीज़ को समेट लेता है।"
+ },
+ "helpAccessOff": {
+ "message": "बंद। <code>chrome://extensions</code> में <b>फ़ाइल URL तक पहुँच की अनुमति दें</b> चालू करें — कोई भी एक्सटेंशन इसे स्वयं चालू नहीं कर सकता।"
+ },
+ "helpAccessUnknown": {
+ "message": "यह ब्राउज़र इसकी जानकारी नहीं देता। यदि सहेजने पर अब भी पूछा जाए, तो <code>chrome://extensions</code> में देखें।"
+ },
+ "helpAccessOn": {
+ "message": "चालू — Bento Tray डिस्क से खोले गए पेज पढ़ सकता है।"
+ },
+ "helpNeverTitle": {
+ "message": "यह कभी क्या नहीं करता"
+ },
+ "helpNeverSub": {
+ "message": "यह केवल ऊपर के फ़ोल्डरों के भीतर पढ़ता-लिखता है, और केवल वही फ़ाइल जिससे कोई पेज वास्तव में खोला गया था — कौन-सी, यह ब्राउज़र बताता है, इसलिए कोई दस्तावेज़ किसी और की फ़ाइल का नाम नहीं ले सकता। आपके दस्तावेज़ों के बारे में कुछ भी कहीं अपलोड नहीं होता, और इस एक्सटेंशन के पास उन्हें अपलोड करने के लिए कोई सर्वर है ही नहीं।"
+ },
+ "helpAboutTitle": {
+ "message": "परिचय"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · Bento परियोजना का हिस्सा · MIT लाइसेंस"
+ },
+ "linkSource": {
+ "message": "GitHub पर स्रोत"
+ },
+ "linkIssues": {
+ "message": "समस्या की शिकायत करें"
+ },
+ "linkReleases": {
+ "message": "रिलीज़"
+ },
+ "primeMiddle": {
+ "message": "वह जो टिकता है"
+ },
+ "primeNote": {
+ "message": "बाकी दोनों भी काम करते हैं, पर Chrome दोबारा पूछता है — पहले वाले के लिए हर बार पुनःआरंभ पर, और आख़िरी वाले के लिए कुछ प्रतीक्षा के बाद।"
+ }
+}
diff --git a/tray/webext/_locales/id/messages.json b/tray/webext/_locales/id/messages.json
new file mode 100644
index 00000000..8bd5bb06
--- /dev/null
+++ b/tray/webext/_locales/id/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Simpan dokumen Bento kembali ke berkas yang Anda buka, tanpa ditanya lokasi tujuan."
+ },
+ "navAll": {
+ "message": "Semua dokumen"
+ },
+ "navFolders": {
+ "message": "Folder"
+ },
+ "navHelp": {
+ "message": "Bantuan & tentang"
+ },
+ "navSettings": {
+ "message": "Setelan"
+ },
+ "addFolder": {
+ "message": "+ Tambahkan folder…"
+ },
+ "searchDocs": {
+ "message": "Cari dokumen"
+ },
+ "searchDocsSlash": {
+ "message": "Cari dokumen /"
+ },
+ "sortTitle": {
+ "message": "Urutkan"
+ },
+ "sortRecent": {
+ "message": "Baru diubah"
+ },
+ "sortName": {
+ "message": "Nama"
+ },
+ "sortFolder": {
+ "message": "Folder"
+ },
+ "newDocument": {
+ "message": "+ Dokumen baru"
+ },
+ "browseAll": {
+ "message": "Jelajahi semua"
+ },
+ "reconnectFolders": {
+ "message": "Sambungkan ulang folder"
+ },
+ "primeIntro": {
+ "message": "Chrome akan bertanya sebentar lagi. Pilih opsi tengah:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — sebuah folder perlu disambungkan ulang"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray perlu disambungkan ulang"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome mencabut izin untuk sebuah folder. Sampai izin itu dipulihkan, setiap penyimpanan akan menanyakan lokasi tujuan."
+ },
+ "reconnect": {
+ "message": "Sambungkan ulang"
+ },
+ "ctxOpenPanel": {
+ "message": "Buka panel Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "Belum ada dokumen Bento di folder Anda."
+ },
+ "noMatches": {
+ "message": "Tidak ada yang cocok dengan “$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Buka satu dokumen di $1 sekali lewat Finder, lalu semua isi folder itu bisa dibuka dari sini."
+ },
+ "encrypted": {
+ "message": "Dilindungi kata sandi"
+ },
+ "notSavedYet": {
+ "message": "Belum disimpan"
+ },
+ "fileAccessOffShort": {
+ "message": "Akses berkas lokal mati"
+ },
+ "noFoldersYet": {
+ "message": "Belum ada folder"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 folder perlu disambungkan ulang"
+ },
+ "statusOneFolder": {
+ "message": "$1 folder · menyimpan di tempat"
+ },
+ "statusFolders": {
+ "message": "$1 folder · menyimpan di tempat"
+ },
+ "renewNotOffered": {
+ "message": "Chrome tidak menawarkan pemulihannya"
+ },
+ "renewTryAfterRestart": {
+ "message": "Coba lagi setelah memulai ulang Chrome"
+ },
+ "fetchingLatest": {
+ "message": "Mengambil Bento terbaru…"
+ },
+ "created": {
+ "message": "$1 dibuat"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 bisa dibaca tetapi belum bisa dibuka — Chrome tidak memberi tahu ekstensi di mana sebuah folder berada di disk. <b>Jelajahi semua</b> menemukannya dengan sekali klik."
+ },
+ "andMore": {
+ "message": " dan $1 lainnya"
+ },
+ "agoJustNow": {
+ "message": "baru saja"
+ },
+ "agoMinutes": {
+ "message": "$1 mnt lalu"
+ },
+ "agoHour": {
+ "message": "$1 jam lalu"
+ },
+ "agoHours": {
+ "message": "$1 jam lalu"
+ },
+ "agoDay": {
+ "message": "$1 hari lalu"
+ },
+ "agoDays": {
+ "message": "$1 hari lalu"
+ },
+ "searchScope": {
+ "message": "Pencarian melihat judul, nama berkas, folder, dan kata-kata di dalam dokumen."
+ },
+ "folderEmpty": {
+ "message": "Belum ada apa pun di folder ini"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Dokumen baru</b> menaruh satu yang baru di sini."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray belum tahu di mana $1 berada di disk. Gunakan “Temukan folder saya”, atau buka satu dokumen di dalamnya lewat Finder sekali."
+ },
+ "cardRenamedTip": {
+ "message": "$1 adalah dokumen Bento dengan nama lain. Ia terbuka dari sini, tetapi penyimpanan akan menanyakan lokasi tujuan — penyimpanan di tempat hanya mengenali berkas berakhiran .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Bernama .html, bukan .bento.html — ia terbuka dari sini, tetapi penyimpanan akan menanyakan lokasi tujuan."
+ },
+ "menuOpen": {
+ "message": "Buka"
+ },
+ "menuDuplicate": {
+ "message": "Duplikat"
+ },
+ "menuRename": {
+ "message": "Ganti nama…"
+ },
+ "menuCopyPath": {
+ "message": "Salin jalur"
+ },
+ "duplicatedAs": {
+ "message": "Diduplikat sebagai $1"
+ },
+ "renamePrompt": {
+ "message": "Ganti nama dokumen"
+ },
+ "renamedTo": {
+ "message": "Diganti namanya menjadi $1"
+ },
+ "pathCopied": {
+ "message": "Jalur disalin"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — belum dibuka"
+ },
+ "setupTitle": {
+ "message": "Dua hal dan Anda siap"
+ },
+ "setupLead": {
+ "message": "Setelah ini, ⌘S pada dokumen yang Anda buka dengan klik ganda akan menulis langsung kembali ke berkasnya — tak pernah lagi ditanya lokasi tujuan."
+ },
+ "chooseFolder": {
+ "message": "Pilih folder…"
+ },
+ "setupStep1": {
+ "message": "Pilih folder tempat dokumen Anda berada"
+ },
+ "setupStep1Note": {
+ "message": "Satu folder luas biasanya cukup — ia mencakup semua yang ada di dalamnya."
+ },
+ "setupStep2": {
+ "message": "Nyalakan akses berkas lokal"
+ },
+ "setupStep2Note": {
+ "message": "Di <code>chrome://extensions</code> → Bento Tray → <b>Izinkan akses ke URL file</b>. Chrome tidak mengizinkan ekstensi menyalakannya sendiri."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Baru memperbarui dan mengira folder Anda ada di sini?</b> Ekstensi tidak terpaket dikenali dari jalur foldernya, jadi salinan baru yang dimuat dari folder lain adalah ekstensi yang berbeda. Folder Anda masih milik yang lama. Sebagai gantinya, ganti berkas di folder aslinya lalu tekan <b>Muat ulang</b> di <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Akses berkas lokal mati</b> — tidak ada yang disimpan di tempat sampai ia dinyalakan. Nyalakan <b>Izinkan akses ke URL file</b> di <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 folder perlu disambungkan ulang.</b> Sambungkan ulang di <b>Setelan</b>, lalu pilih <b>Izinkan setiap kunjungan</b> — satu-satunya opsi yang bertahan."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> bisa didaftar tetapi belum bisa dibuka — Chrome tidak pernah memberi tahu ekstensi di mana sebuah folder berada di disk."
+ },
+ "findFolders": {
+ "message": "Temukan folder saya"
+ },
+ "looking": {
+ "message": "Mencari…"
+ },
+ "findDeclined": {
+ "message": "<b>Tidak masalah.</b> Sebagai gantinya, buka satu dokumen di $1 lewat Finder sekali — halaman ini akan menyadarinya."
+ },
+ "foundFolder": {
+ "message": "Menemukan $1 folder"
+ },
+ "foundFolders": {
+ "message": "Menemukan $1 folder"
+ },
+ "foundNothing": {
+ "message": "Belum ada apa pun di riwayat — buka satu dokumen lewat Finder"
+ },
+ "setFoldersSub": {
+ "message": "Dokumen di dalamnya disimpan langsung kembali ke berkasnya, tanpa ditanya lokasi tujuan. Sebuah folder mencakup semua yang ada di dalamnya."
+ },
+ "noneYet": {
+ "message": "Belum ada."
+ },
+ "savesInPlace": {
+ "message": "menyimpan di tempat"
+ },
+ "needsReconnecting": {
+ "message": "perlu disambungkan ulang"
+ },
+ "reconnectTip": {
+ "message": "Chrome akan meminta izin memulihkan folder ini. “Jangan izinkan” melepaskannya, dan setelah itu Chrome menunggu setidaknya satu kali mulai ulang sebelum bertanya lagi."
+ },
+ "remove": {
+ "message": "Hapus"
+ },
+ "removeTip": {
+ "message": "Mencabut akses. Chrome mungkin masih mengingat izinnya, jadi menambahkan folder itu kembali mungkin tidak bertanya lagi."
+ },
+ "setAccessTitle": {
+ "message": "Akses berkas lokal"
+ },
+ "setAccessSub": {
+ "message": "Chrome tidak mengizinkan ekstensi menyalakannya sendiri, dan tanpa ini tidak ada yang berfungsi."
+ },
+ "stateOn": {
+ "message": "Nyala"
+ },
+ "stateOff": {
+ "message": "Mati"
+ },
+ "stateUnknown": {
+ "message": "Tidak diketahui"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray dapat membaca halaman yang Anda buka dari disk."
+ },
+ "accessOffNote": {
+ "message": "Buka chrome://extensions, cari Bento Tray, nyalakan “Izinkan akses ke URL file”."
+ },
+ "accessUnknownNote": {
+ "message": "Peramban ini tidak melaporkannya. Jika penyimpanan masih bertanya, periksa di chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Versi"
+ },
+ "setVersionUnpacked": {
+ "message": "Salinan ini dimuat tidak terpaket, jadi Chrome tidak akan pernah memperbaruinya."
+ },
+ "setVersionStore": {
+ "message": "Dipasang dari toko, jadi ia memperbarui dirinya sendiri."
+ },
+ "versionAvailable": {
+ "message": "$1 tersedia"
+ },
+ "versionUpToDate": {
+ "message": "terkini per pemeriksaan terakhir"
+ },
+ "versionManaged": {
+ "message": "dijaga tetap terkini oleh peramban"
+ },
+ "getIt": {
+ "message": "Ambil"
+ },
+ "checkNow": {
+ "message": "Periksa sekarang"
+ },
+ "autoCheckPref": {
+ "message": "<b>Periksa versi baru saat peramban dimulai.</b><br>Satu permintaan ke bento.page untuk sebuah berkas statis. Ia tidak mengirim pengenal, nomor versi, maupun apa pun tentang dokumen Anda — perbandingannya terjadi di sini. Matikan dan tidak ada yang pernah diminta; <b>Periksa sekarang</b> tetap berfungsi."
+ },
+ "expectedSha": {
+ "message": "SHA-256 yang diharapkan untuk berkas zip: $1"
+ },
+ "setReachTitle": {
+ "message": "Apa yang bisa dijangkau"
+ },
+ "setReachSub": {
+ "message": "Hanya folder di atas, dan hanya berkas asal sebuah halaman benar-benar dibuka. Tidak ada yang diunggah dan tidak ada yang dibaca di tempat lain."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 tersedia.</b> Salinan ini dimuat tidak terpaket, jadi Chrome tidak akan pernah memperbaruinya."
+ },
+ "updateStep1": {
+ "message": "Unduh dari GitHub"
+ },
+ "updateStep2": {
+ "message": "Ganti berkas <b>di folder tempat Anda memuatnya</b> — folder yang sama, atau Chrome menganggapnya ekstensi berbeda dan folder yang sudah diizinkan tidak ikut serta"
+ },
+ "updateStep3": {
+ "message": "Buka <code>chrome://extensions</code> lalu tekan <b>Muat ulang</b> pada Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Mengambil $1…"
+ },
+ "createdIn": {
+ "message": "Membuat $1 ($2) di $3"
+ },
+ "intoFolder": {
+ "message": "ke $1"
+ },
+ "helpWhatTitle": {
+ "message": "Apa yang dilakukan Bento Tray"
+ },
+ "helpWhatSub": {
+ "message": "Dokumen Bento adalah satu berkas HTML yang membawa editornya sendiri. Dibuka langsung dari disk, peramban tidak mengizinkannya menulis kembali ke dirinya sendiri — jadi setiap penyimpanan menanyakan lokasi tujuan. Bento Tray menghilangkan pertanyaan itu."
+ },
+ "tourSaveTitle": {
+ "message": "Simpan di tempat"
+ },
+ "tourSaveBody": {
+ "message": "⌘S menulis langsung kembali ke berkas yang Anda buka, tanpa dialog. Simpan otomatis dan pembaruan di tempat menempuh jalur yang sama."
+ },
+ "tourFindTitle": {
+ "message": "Temukan dokumen Anda"
+ },
+ "tourFindBody": {
+ "message": "Setiap dokumen Bento di folder Anda, dengan judul aslinya dan gambar halaman pertamanya. Pencarian mencakup apa yang tertulis di dalamnya."
+ },
+ "tourSwitchTitle": {
+ "message": "Berpindah sambil bekerja"
+ },
+ "tourSwitchBody": {
+ "message": "Tekan <kbd>Alt</kbd>+<kbd>B</kbd>, atau klik kanan di dalam dokumen, untuk panel di sebelahnya."
+ },
+ "tourNewTitle": {
+ "message": "Buat yang baru"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Dokumen baru</b> mengambil rilis terkini Slides, Spaces, atau Dash dan menaruh dokumen baru di folder Anda."
+ },
+ "helpNeedsTitle": {
+ "message": "Apa yang dibutuhkan dari Anda"
+ },
+ "helpNeedsSub": {
+ "message": "Dua hal, keduanya di luar kuasa ekstensi ini untuk mengaturnya."
+ },
+ "helpFolder": {
+ "message": "Sebuah folder"
+ },
+ "helpFolderGranted": {
+ "message": "$1 diizinkan — dokumen di dalamnya disimpan di tempat"
+ },
+ "helpFolderNone": {
+ "message": "Belum dipilih. Satu folder luas mencakup semua yang ada di dalamnya."
+ },
+ "helpAccessOff": {
+ "message": "Mati. Nyalakan <b>Izinkan akses ke URL file</b> di <code>chrome://extensions</code> — tidak ada ekstensi yang bisa menyalakannya sendiri."
+ },
+ "helpAccessUnknown": {
+ "message": "Peramban ini tidak melaporkannya. Jika penyimpanan masih bertanya, periksa di <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Nyala — Bento Tray dapat membaca halaman yang Anda buka dari disk."
+ },
+ "helpNeverTitle": {
+ "message": "Apa yang tidak pernah dilakukannya"
+ },
+ "helpNeverSub": {
+ "message": "Ia hanya membaca dan menulis di dalam folder di atas, dan hanya berkas asal sebuah halaman benar-benar dibuka — peramban yang memberi tahu yang mana, sehingga sebuah dokumen tidak bisa menyebut berkas milik orang lain. Tidak ada apa pun tentang dokumen Anda yang diunggah ke mana pun, dan ekstensi ini tidak punya server untuk mengunggahnya."
+ },
+ "helpAboutTitle": {
+ "message": "Tentang"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · bagian dari proyek Bento · berlisensi MIT"
+ },
+ "linkSource": {
+ "message": "Sumber di GitHub"
+ },
+ "linkIssues": {
+ "message": "Laporkan masalah"
+ },
+ "linkReleases": {
+ "message": "Rilis"
+ },
+ "primeMiddle": {
+ "message": "yang bertahan"
+ },
+ "primeNote": {
+ "message": "Dua lainnya juga berfungsi, tetapi Chrome akan bertanya lagi — setiap kali mulai ulang untuk yang pertama, dan setelah menunggu untuk yang terakhir."
+ }
+}
diff --git a/tray/webext/_locales/it/messages.json b/tray/webext/_locales/it/messages.json
new file mode 100644
index 00000000..ea1f458d
--- /dev/null
+++ b/tray/webext/_locales/it/messages.json
@@ -0,0 +1,446 @@
+{
+ "appDesc": {
+ "message": "Salva un documento Bento nel file che hai aperto, senza chiedere dove metterlo.",
+ "description": "Chrome Web Store listing description. 132 characters maximum — the store truncates."
+ },
+ "navAll": {
+ "message": "Tutti i documenti"
+ },
+ "navFolders": {
+ "message": "Cartelle"
+ },
+ "navHelp": {
+ "message": "Aiuto e informazioni"
+ },
+ "navSettings": {
+ "message": "Impostazioni"
+ },
+ "addFolder": {
+ "message": "+ Aggiungi una cartella…"
+ },
+ "searchDocs": {
+ "message": "Cerca documenti"
+ },
+ "searchDocsSlash": {
+ "message": "Cerca documenti /"
+ },
+ "sortTitle": {
+ "message": "Ordina"
+ },
+ "sortRecent": {
+ "message": "Modificati di recente"
+ },
+ "sortName": {
+ "message": "Nome"
+ },
+ "sortFolder": {
+ "message": "Cartella"
+ },
+ "newDocument": {
+ "message": "+ Nuovo documento"
+ },
+ "browseAll": {
+ "message": "Sfoglia tutti"
+ },
+ "reconnectFolders": {
+ "message": "Ricollega le cartelle"
+ },
+ "primeIntro": {
+ "message": "Chrome sta per chiedere. Scegli l’opzione centrale:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — una cartella va ricollegata",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray va ricollegato",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome ha revocato il permesso per una cartella. Finché non viene ripristinato, salvando un documento verrà chiesto dove metterlo.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnect": {
+ "message": "Ricollega"
+ },
+ "ctxOpenPanel": {
+ "message": "Apri il pannello Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "Ancora nessun documento Bento nelle tue cartelle."
+ },
+ "noMatches": {
+ "message": "Nulla corrisponde a «$1»"
+ },
+ "rowUnplacedTip": {
+ "message": "Apri una volta un documento in $1 dal Finder e tutto ciò che c’è in quella cartella si potrà aprire da qui."
+ },
+ "encrypted": {
+ "message": "Protetto da password"
+ },
+ "notSavedYet": {
+ "message": "Non ancora salvato"
+ },
+ "fileAccessOffShort": {
+ "message": "L’accesso ai file locali è disattivato",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noFoldersYet": {
+ "message": "Ancora nessuna cartella"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 cartella va ricollegata",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "statusOneFolder": {
+ "message": "$1 cartella · salva sul posto"
+ },
+ "statusFolders": {
+ "message": "$1 cartelle · salva sul posto"
+ },
+ "renewNotOffered": {
+ "message": "Chrome non ha proposto di ripristinarla",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "renewTryAfterRestart": {
+ "message": "Riprova dopo aver riavviato Chrome",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "fetchingLatest": {
+ "message": "Scaricamento dell’ultimo Bento…"
+ },
+ "created": {
+ "message": "$1 creato"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 può essere letto, ma non ancora aperto: Chrome non dice a un’estensione dove si trova una cartella sul disco. <b>Sfoglia tutti</b> li trova con un clic.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "andMore": {
+ "message": " e altre $1"
+ },
+ "agoJustNow": {
+ "message": "proprio ora"
+ },
+ "agoMinutes": {
+ "message": "$1 min fa"
+ },
+ "agoHour": {
+ "message": "$1 ora fa"
+ },
+ "agoHours": {
+ "message": "$1 ore fa"
+ },
+ "agoDay": {
+ "message": "$1 giorno fa"
+ },
+ "agoDays": {
+ "message": "$1 giorni fa"
+ },
+ "searchScope": {
+ "message": "La ricerca guarda titoli, nomi di file, cartelle e il testo dentro i documenti."
+ },
+ "folderEmpty": {
+ "message": "Ancora niente in questa cartella"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Nuovo documento</b> ne mette uno qui."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray non sa ancora dove si trova $1 sul disco. Usa «Trova le mie cartelle» o apri una volta un documento dal Finder.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "cardRenamedTip": {
+ "message": "$1 è un documento Bento con un altro nome. Si apre da qui, ma al salvataggio chiederà dove metterlo — il salvataggio sul posto riconosce solo i file che finiscono in .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Si chiama .html anziché .bento.html — si apre da qui, ma al salvataggio chiederà dove metterlo."
+ },
+ "menuOpen": {
+ "message": "Apri"
+ },
+ "menuDuplicate": {
+ "message": "Duplica"
+ },
+ "menuRename": {
+ "message": "Rinomina…"
+ },
+ "menuCopyPath": {
+ "message": "Copia percorso"
+ },
+ "duplicatedAs": {
+ "message": "Duplicato come $1"
+ },
+ "renamePrompt": {
+ "message": "Rinomina il documento"
+ },
+ "renamedTo": {
+ "message": "Rinominato in $1"
+ },
+ "pathCopied": {
+ "message": "Percorso copiato"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — non ancora aperta"
+ },
+ "setupTitle": {
+ "message": "Due cose e sei a posto"
+ },
+ "setupLead": {
+ "message": "Dopodiché, ⌘S su un documento aperto con doppio clic scrive direttamente nel file — senza mai chiedere dove."
+ },
+ "chooseFolder": {
+ "message": "Scegli una cartella…"
+ },
+ "setupStep1": {
+ "message": "Scegli la cartella dove vivono i tuoi documenti"
+ },
+ "setupStep1Note": {
+ "message": "Di solito basta una cartella ampia — copre tutto ciò che contiene."
+ },
+ "setupStep2": {
+ "message": "Attiva l’accesso ai file locali",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupStep2Note": {
+ "message": "In <code>chrome://extensions</code> → Bento Tray → <b>Consenti accesso agli URL dei file</b>. Chrome non lascia che un’estensione lo attivi da sé.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Hai aggiornato e ti aspettavi di trovare le tue cartelle?</b> Un’estensione decompressa è identificata dal percorso della sua cartella, quindi caricarne una copia da un’altra cartella la rende un’estensione diversa. Le tue cartelle restano concesse alla precedente. Sostituisci invece i file nella cartella originale e premi <b>Ricarica</b> in <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>L’accesso ai file locali è disattivato</b> — finché non è attivo, nulla si salva sul posto. Attiva <b>Consenti accesso agli URL dei file</b> in <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 cartella va ricollegata.</b> Ricollegala nelle <b>Impostazioni</b> e scegli l’opzione centrale — l’unica che dura.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> si può elencare ma non ancora aprire — Chrome non dice mai a un’estensione dove si trova una cartella sul disco.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "findFolders": {
+ "message": "Trova le mie cartelle"
+ },
+ "looking": {
+ "message": "Ricerca…"
+ },
+ "findDeclined": {
+ "message": "<b>Nessun problema.</b> Apri invece una volta un documento in $1 dal Finder — questa pagina se ne accorge."
+ },
+ "foundFolder": {
+ "message": "$1 cartella trovata"
+ },
+ "foundFolders": {
+ "message": "$1 cartelle trovate"
+ },
+ "foundNothing": {
+ "message": "Ancora niente nella cronologia — apri un documento dal Finder"
+ },
+ "setFoldersSub": {
+ "message": "I documenti al loro interno si salvano direttamente nel file, senza chiedere dove. Una cartella copre tutto ciò che contiene."
+ },
+ "noneYet": {
+ "message": "Ancora nessuna."
+ },
+ "savesInPlace": {
+ "message": "salva sul posto"
+ },
+ "needsReconnecting": {
+ "message": "va ricollegata",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnectTip": {
+ "message": "Chrome chiederà di ripristinare questa cartella. Rifiutare la rimuove, e poi Chrome aspetta almeno un riavvio prima di riproporlo.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "remove": {
+ "message": "Rimuovi"
+ },
+ "removeTip": {
+ "message": "Toglie l’accesso. Chrome potrebbe ricordare comunque il permesso, quindi riaggiungendo la cartella potrebbe non chiedere di nuovo.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessTitle": {
+ "message": "Accesso ai file locali",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessSub": {
+ "message": "Chrome non lascia che un’estensione lo attivi da sé, e senza non funziona nulla.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "stateOn": {
+ "message": "Attivo"
+ },
+ "stateOff": {
+ "message": "Disattivato"
+ },
+ "stateUnknown": {
+ "message": "Sconosciuto"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray può leggere le pagine che hai aperto dal disco.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessOffNote": {
+ "message": "Apri chrome://extensions, trova Bento Tray e attiva «Consenti accesso agli URL dei file».",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessUnknownNote": {
+ "message": "Questo browser non lo indica. Se il salvataggio continua a chiedere, controlla in chrome://extensions.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setVersionTitle": {
+ "message": "Versione"
+ },
+ "setVersionUnpacked": {
+ "message": "Questa copia è stata caricata decompressa, quindi Chrome non la aggiornerà mai."
+ },
+ "setVersionStore": {
+ "message": "Installato dallo store, quindi si aggiorna da solo."
+ },
+ "versionAvailable": {
+ "message": "$1 è disponibile"
+ },
+ "versionUpToDate": {
+ "message": "aggiornato all’ultimo controllo"
+ },
+ "versionManaged": {
+ "message": "tenuto aggiornato dal browser"
+ },
+ "getIt": {
+ "message": "Ottieni"
+ },
+ "checkNow": {
+ "message": "Controlla ora"
+ },
+ "autoCheckPref": {
+ "message": "<b>Cerca una nuova versione all’avvio del browser.</b><br>Una richiesta a bento.page per un file statico. Non invia identificatori, né il numero di versione, né nulla sui tuoi documenti — il confronto avviene qui. Se disattivata non viene mai richiesto nulla; <b>Controlla ora</b> continua a funzionare.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "expectedSha": {
+ "message": "SHA-256 atteso dello zip: $1"
+ },
+ "setReachTitle": {
+ "message": "A cosa può accedere",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setReachSub": {
+ "message": "Solo le cartelle qui sopra, e solo il file da cui una pagina è stata aperta. Nulla viene caricato e nulla viene letto altrove.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 è disponibile.</b> Questa copia è stata caricata decompressa, quindi Chrome non la aggiornerà mai."
+ },
+ "updateStep1": {
+ "message": "Scaricalo da GitHub"
+ },
+ "updateStep2": {
+ "message": "Sostituisci i file <b>nella cartella da cui l’hai caricato</b> — la stessa cartella, altrimenti Chrome lo tratta come un’altra estensione e le cartelle concesse non lo seguono",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateStep3": {
+ "message": "Apri <code>chrome://extensions</code> e premi <b>Ricarica</b> su Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Scaricamento di $1…"
+ },
+ "createdIn": {
+ "message": "$1 ($2) creato in $3"
+ },
+ "intoFolder": {
+ "message": "in $1"
+ },
+ "helpWhatTitle": {
+ "message": "Cosa fa Bento Tray"
+ },
+ "helpWhatSub": {
+ "message": "Un documento Bento è un file HTML che porta con sé il proprio editor. Aperto direttamente dal disco, il browser non gli permette di riscriversi — quindi al salvataggio chiede ogni volta dove metterlo. Bento Tray toglie quella domanda."
+ },
+ "tourSaveTitle": {
+ "message": "Salva sul posto"
+ },
+ "tourSaveBody": {
+ "message": "⌘S scrive direttamente nel file che hai aperto, senza finestre. Il salvataggio automatico e gli aggiornamenti seguono la stessa strada."
+ },
+ "tourFindTitle": {
+ "message": "Trova i tuoi documenti"
+ },
+ "tourFindBody": {
+ "message": "Ogni documento Bento nelle tue cartelle, con il titolo vero e un’immagine della prima pagina. La ricerca copre anche ciò che c’è scritto dentro."
+ },
+ "tourSwitchTitle": {
+ "message": "Cambia mentre lavori"
+ },
+ "tourSwitchBody": {
+ "message": "Premi <kbd>Alt</kbd>+<kbd>B</kbd>, o fai clic destro dentro un documento, per avere un pannello accanto."
+ },
+ "tourNewTitle": {
+ "message": "Creane uno nuovo"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Nuovo documento</b> scarica la versione attuale di Slides, Spaces o Dash e mette un documento nuovo nella tua cartella."
+ },
+ "helpNeedsTitle": {
+ "message": "Cosa le serve da te"
+ },
+ "helpNeedsSub": {
+ "message": "Due cose, entrambe fuori dalla portata di questa estensione."
+ },
+ "helpFolder": {
+ "message": "Una cartella"
+ },
+ "helpFolderGranted": {
+ "message": "$1 concesse — i documenti al loro interno si salvano sul posto"
+ },
+ "helpFolderNone": {
+ "message": "Non ancora scelta. Una cartella ampia copre tutto ciò che contiene."
+ },
+ "helpAccessOff": {
+ "message": "Disattivato. Attiva <b>Consenti accesso agli URL dei file</b> in <code>chrome://extensions</code> — nessuna estensione può attivarlo da sé.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessUnknown": {
+ "message": "Questo browser non lo indica. Se il salvataggio continua a chiedere, controlla in <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessOn": {
+ "message": "Attivo — Bento Tray può leggere le pagine che hai aperto dal disco.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverTitle": {
+ "message": "Cosa non fa mai",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverSub": {
+ "message": "Legge e scrive solo nelle cartelle qui sopra, e solo il file da cui una pagina è stata effettivamente aperta — è il browser a dire quale, quindi un documento non può indicare il file di un altro. Nulla dei tuoi documenti viene caricato da nessuna parte, e l’estensione non ha nemmeno un server a cui caricarlo.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAboutTitle": {
+ "message": "Informazioni"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · parte del progetto Bento · licenza MIT"
+ },
+ "linkSource": {
+ "message": "Codice su GitHub"
+ },
+ "linkIssues": {
+ "message": "Segnala un problema"
+ },
+ "linkReleases": {
+ "message": "Versioni"
+ },
+ "primeMiddle": {
+ "message": "quella che dura"
+ },
+ "primeNote": {
+ "message": "Anche le altre due funzionano, ma Chrome chiederà di nuovo — la prima a ogni riavvio, l’ultima dopo un’attesa."
+ }
+}
diff --git a/tray/webext/_locales/ja/messages.json b/tray/webext/_locales/ja/messages.json
new file mode 100644
index 00000000..95252f61
--- /dev/null
+++ b/tray/webext/_locales/ja/messages.json
@@ -0,0 +1,446 @@
+{
+ "appDesc": {
+ "message": "開いた Bento ドキュメントを、保存先を尋ねられることなく元のファイルに保存します。",
+ "description": "Chrome Web Store listing description. 132 characters maximum — the store truncates."
+ },
+ "navAll": {
+ "message": "すべてのドキュメント"
+ },
+ "navFolders": {
+ "message": "フォルダ"
+ },
+ "navHelp": {
+ "message": "ヘルプと情報"
+ },
+ "navSettings": {
+ "message": "設定"
+ },
+ "addFolder": {
+ "message": "+ フォルダを追加…"
+ },
+ "searchDocs": {
+ "message": "ドキュメントを検索"
+ },
+ "searchDocsSlash": {
+ "message": "ドキュメントを検索 /"
+ },
+ "sortTitle": {
+ "message": "並べ替え"
+ },
+ "sortRecent": {
+ "message": "最近変更したもの"
+ },
+ "sortName": {
+ "message": "名前"
+ },
+ "sortFolder": {
+ "message": "フォルダ"
+ },
+ "newDocument": {
+ "message": "+ 新規ドキュメント"
+ },
+ "browseAll": {
+ "message": "すべて表示"
+ },
+ "reconnectFolders": {
+ "message": "フォルダを再接続"
+ },
+ "primeIntro": {
+ "message": "次に Chrome が尋ねます。真ん中を選んでください:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — フォルダの再接続が必要です",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray の再接続が必要です",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome がフォルダの権限を取り消しました。元に戻すまで、ドキュメントの保存時に保存先を尋ねられます。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnect": {
+ "message": "再接続"
+ },
+ "ctxOpenPanel": {
+ "message": "Bento Tray パネルを開く"
+ },
+ "panelEmpty": {
+ "message": "フォルダ内にまだ Bento ドキュメントがありません。"
+ },
+ "noMatches": {
+ "message": "「$1」に一致するものはありません"
+ },
+ "rowUnplacedTip": {
+ "message": "$1 のドキュメントを Finder から一度開けば、そのフォルダのすべてをここから開けるようになります。"
+ },
+ "encrypted": {
+ "message": "パスワード保護あり"
+ },
+ "notSavedYet": {
+ "message": "まだ保存されていません"
+ },
+ "fileAccessOffShort": {
+ "message": "ローカルファイルへのアクセスがオフです",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noFoldersYet": {
+ "message": "フォルダがまだありません"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 個のフォルダの再接続が必要です",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "statusOneFolder": {
+ "message": "$1 個のフォルダ · 上書き保存"
+ },
+ "statusFolders": {
+ "message": "$1 個のフォルダ · 上書き保存"
+ },
+ "renewNotOffered": {
+ "message": "Chrome は復元を提案しませんでした",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "renewTryAfterRestart": {
+ "message": "Chrome を再起動してからもう一度お試しください",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "fetchingLatest": {
+ "message": "最新の Bento を取得中…"
+ },
+ "created": {
+ "message": "$1 を作成しました"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 は読み取れますが、まだ開けません。Chrome はフォルダーのディスク上の場所を拡張機能に伝えないためです。<b>すべて表示</b> ならワンクリックで見つかります。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "andMore": {
+ "message": "ほか $1 件"
+ },
+ "agoJustNow": {
+ "message": "たった今"
+ },
+ "agoMinutes": {
+ "message": "$1 分前"
+ },
+ "agoHour": {
+ "message": "$1 時間前"
+ },
+ "agoHours": {
+ "message": "$1 時間前"
+ },
+ "agoDay": {
+ "message": "$1 日前"
+ },
+ "agoDays": {
+ "message": "$1 日前"
+ },
+ "searchScope": {
+ "message": "検索対象はタイトル、ファイル名、フォルダ、そしてドキュメント内の文章です。"
+ },
+ "folderEmpty": {
+ "message": "このフォルダにはまだ何もありません"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ 新規ドキュメント</b>でここに 1 つ作成できます。"
+ },
+ "cardUnplacedTip": {
+ "message": "$1 がディスク上のどこにあるか、Bento Tray はまだ知りません。「フォルダを探す」を使うか、Finder からそのフォルダのドキュメントを一度開いてください。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "cardRenamedTip": {
+ "message": "$1 は別名の Bento ドキュメントです。ここから開けますが、保存時に保存先を尋ねられます — 上書き保存は .bento.html で終わるファイルのみ認識します。"
+ },
+ "badgeRenamed": {
+ "message": ".bento.html ではなく .html という名前です — ここから開けますが、保存時に保存先を尋ねられます。"
+ },
+ "menuOpen": {
+ "message": "開く"
+ },
+ "menuDuplicate": {
+ "message": "複製"
+ },
+ "menuRename": {
+ "message": "名前を変更…"
+ },
+ "menuCopyPath": {
+ "message": "パスをコピー"
+ },
+ "duplicatedAs": {
+ "message": "$1 として複製しました"
+ },
+ "renamePrompt": {
+ "message": "ドキュメントの名前を変更"
+ },
+ "renamedTo": {
+ "message": "$1 に名前を変更しました"
+ },
+ "pathCopied": {
+ "message": "パスをコピーしました"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — まだ開いていません"
+ },
+ "setupTitle": {
+ "message": "2 つだけで準備完了"
+ },
+ "setupLead": {
+ "message": "これが済めば、ダブルクリックで開いたドキュメントで ⌘S を押すと、保存先を尋ねられることなく元のファイルへ直接書き戻されます。"
+ },
+ "chooseFolder": {
+ "message": "フォルダを選択…"
+ },
+ "setupStep1": {
+ "message": "ドキュメントを置いているフォルダを選ぶ"
+ },
+ "setupStep1Note": {
+ "message": "通常は広めのフォルダを 1 つで十分です — 中身すべてが対象になります。"
+ },
+ "setupStep2": {
+ "message": "ローカルファイルへのアクセスをオンにする",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupStep2Note": {
+ "message": "<code>chrome://extensions</code> → Bento Tray → <b>ファイルの URL へのアクセスを許可する</b>。Chrome は拡張機能が自分でオンにすることを許しません。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>更新したのにフォルダが見当たりませんか。</b>展開した拡張機能はフォルダのパスで識別されるため、別のフォルダから新しいコピーを読み込むと別の拡張機能として扱われます。フォルダは以前のコピーに許可されたままです。元のフォルダのファイルを置き換え、<code>chrome://extensions</code> で<b>更新</b>を押してください。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>ローカルファイルへのアクセスがオフです</b> — オンにするまで上書き保存はできません。<code>chrome://extensions</code> で<b>ファイルの URL へのアクセスを許可する</b>をオンにしてください。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 個のフォルダの再接続が必要です。</b><b>設定</b>で再接続し、真ん中の選択肢を選んでください — 唯一ずっと続くものです。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> は一覧に出せますがまだ開けません — Chrome は拡張機能にフォルダのディスク上の場所を教えません。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "findFolders": {
+ "message": "フォルダを探す"
+ },
+ "looking": {
+ "message": "検索中…"
+ },
+ "findDeclined": {
+ "message": "<b>問題ありません。</b>代わりに $1 のドキュメントを Finder から一度開いてください — このページが気づきます。"
+ },
+ "foundFolder": {
+ "message": "$1 個のフォルダが見つかりました"
+ },
+ "foundFolders": {
+ "message": "$1 個のフォルダが見つかりました"
+ },
+ "foundNothing": {
+ "message": "履歴にまだありません — Finder からドキュメントを 1 つ開いてください"
+ },
+ "setFoldersSub": {
+ "message": "この中のドキュメントは、保存先を尋ねられることなく元のファイルへ直接保存されます。フォルダは中身すべてを対象にします。"
+ },
+ "noneYet": {
+ "message": "まだありません。"
+ },
+ "savesInPlace": {
+ "message": "上書き保存"
+ },
+ "needsReconnecting": {
+ "message": "再接続が必要",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnectTip": {
+ "message": "Chrome がこのフォルダの復元を尋ねます。拒否するとフォルダは外れ、その後 Chrome は少なくとも 1 回の再起動を待ってから再度尋ねます。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "remove": {
+ "message": "削除"
+ },
+ "removeTip": {
+ "message": "アクセスを解除します。Chrome 側は権限を覚えている場合があるため、再度追加しても尋ねられないことがあります。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessTitle": {
+ "message": "ローカルファイルへのアクセス",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessSub": {
+ "message": "Chrome は拡張機能が自分でこれをオンにすることを許しません。オンでなければ何も動きません。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "stateOn": {
+ "message": "オン"
+ },
+ "stateOff": {
+ "message": "オフ"
+ },
+ "stateUnknown": {
+ "message": "不明"
+ },
+ "accessOnNote": {
+ "message": "ディスクから開いたページを Bento Tray が読み取れます。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessOffNote": {
+ "message": "chrome://extensions を開き、Bento Tray を探して「ファイルの URL へのアクセスを許可する」をオンにしてください。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessUnknownNote": {
+ "message": "このブラウザは状態を報告しません。保存時に保存先を尋ねられる場合は chrome://extensions で確認してください。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setVersionTitle": {
+ "message": "バージョン"
+ },
+ "setVersionUnpacked": {
+ "message": "このコピーは展開して読み込まれたため、Chrome が更新することはありません。"
+ },
+ "setVersionStore": {
+ "message": "ストアからインストールされているため、自動で更新されます。"
+ },
+ "versionAvailable": {
+ "message": "$1 が利用できます"
+ },
+ "versionUpToDate": {
+ "message": "前回の確認時点で最新"
+ },
+ "versionManaged": {
+ "message": "ブラウザが最新に保っています"
+ },
+ "getIt": {
+ "message": "入手"
+ },
+ "checkNow": {
+ "message": "今すぐ確認"
+ },
+ "autoCheckPref": {
+ "message": "<b>ブラウザの起動時に新しいバージョンを確認する。</b><br>bento.page の静的ファイルへのリクエストが 1 回だけ。識別子もバージョン番号も、ドキュメントに関する情報も送りません — 比較はこの端末で行われます。オフにすれば何も送信されず、<b>今すぐ確認</b>は引き続き使えます。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "expectedSha": {
+ "message": "zip の想定 SHA-256: $1"
+ },
+ "setReachTitle": {
+ "message": "アクセスできる範囲",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setReachSub": {
+ "message": "上のフォルダだけ、しかもページが実際に開かれた元のファイルだけです。どこにもアップロードせず、他の場所を読むこともありません。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 が利用できます。</b>このコピーは展開して読み込まれたため、Chrome が更新することはありません。"
+ },
+ "updateStep1": {
+ "message": "GitHub からダウンロード"
+ },
+ "updateStep2": {
+ "message": "<b>読み込んだフォルダの中で</b>ファイルを置き換えてください — 同じフォルダでないと Chrome は別の拡張機能として扱い、許可済みのフォルダは引き継がれません",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateStep3": {
+ "message": "<code>chrome://extensions</code> を開き、Bento Tray の<b>更新</b>を押す"
+ },
+ "fetchingApp": {
+ "message": "$1 を取得中…"
+ },
+ "createdIn": {
+ "message": "$3 に $1($2)を作成しました"
+ },
+ "intoFolder": {
+ "message": "$1 へ"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray でできること"
+ },
+ "helpWhatSub": {
+ "message": "Bento ドキュメントは、エディタごと入った 1 つの HTML ファイルです。ディスクから直接開くと、ブラウザは自分自身への書き戻しを許さないため、保存のたびに保存先を尋ねられます。Bento Tray はその質問をなくします。"
+ },
+ "tourSaveTitle": {
+ "message": "その場で保存"
+ },
+ "tourSaveBody": {
+ "message": "⌘S はダイアログなしで、開いたファイルへ直接書き戻します。自動保存とアップデートも同じ経路を通ります。"
+ },
+ "tourFindTitle": {
+ "message": "ドキュメントを見つける"
+ },
+ "tourFindBody": {
+ "message": "フォルダ内のすべての Bento ドキュメントを、本当のタイトルと 1 ページ目の画像付きで表示します。検索は中の文章も対象です。"
+ },
+ "tourSwitchTitle": {
+ "message": "作業しながら切り替える"
+ },
+ "tourSwitchBody": {
+ "message": "<kbd>Alt</kbd>+<kbd>B</kbd> を押すか、ドキュメント内で右クリックすると、隣にパネルが開きます。"
+ },
+ "tourNewTitle": {
+ "message": "新しく作る"
+ },
+ "tourNewBody": {
+ "message": "<b>+ 新規ドキュメント</b>は Slides・Spaces・Dash の最新版を取得し、フォルダに新しいドキュメントを置きます。"
+ },
+ "helpNeedsTitle": {
+ "message": "必要なもの"
+ },
+ "helpNeedsSub": {
+ "message": "2 つだけ。どちらもこの拡張機能では用意できないものです。"
+ },
+ "helpFolder": {
+ "message": "フォルダ"
+ },
+ "helpFolderGranted": {
+ "message": "$1 個を許可済み — 中のドキュメントは上書き保存されます"
+ },
+ "helpFolderNone": {
+ "message": "まだ選ばれていません。広めのフォルダを 1 つ選べば中身すべてが対象になります。"
+ },
+ "helpAccessOff": {
+ "message": "オフです。<code>chrome://extensions</code> で<b>ファイルの URL へのアクセスを許可する</b>をオンにしてください — 拡張機能が自分でオンにすることはできません。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessUnknown": {
+ "message": "このブラウザは状態を報告しません。保存時に保存先を尋ねられる場合は <code>chrome://extensions</code> で確認してください。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessOn": {
+ "message": "オン — ディスクから開いたページを Bento Tray が読み取れます。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverTitle": {
+ "message": "決してしないこと",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverSub": {
+ "message": "読み書きするのは上のフォルダの中だけ、しかもページが実際に開かれた元のファイルだけです — どのファイルかはブラウザが伝えるので、ドキュメントが他人のファイルを指定することはできません。ドキュメントの内容がどこかへ送られることはなく、送る先のサーバーもありません。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAboutTitle": {
+ "message": "このアプリについて"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · Bento プロジェクトの一部 · MIT ライセンス"
+ },
+ "linkSource": {
+ "message": "GitHub のソース"
+ },
+ "linkIssues": {
+ "message": "問題を報告"
+ },
+ "linkReleases": {
+ "message": "リリース"
+ },
+ "primeMiddle": {
+ "message": "ずっと続くもの"
+ },
+ "primeNote": {
+ "message": "他の 2 つでも動きますが、Chrome は再び尋ねます — 1 つ目は再起動のたびに、最後のものはしばらく待ってから。"
+ }
+}
diff --git a/tray/webext/_locales/ko/messages.json b/tray/webext/_locales/ko/messages.json
new file mode 100644
index 00000000..38dc0d45
--- /dev/null
+++ b/tray/webext/_locales/ko/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Bento 문서를 저장 위치를 묻는 창 없이 열었던 파일에 그대로 저장합니다."
+ },
+ "navAll": {
+ "message": "모든 문서"
+ },
+ "navFolders": {
+ "message": "폴더"
+ },
+ "navHelp": {
+ "message": "도움말 및 정보"
+ },
+ "navSettings": {
+ "message": "설정"
+ },
+ "addFolder": {
+ "message": "+ 폴더 추가…"
+ },
+ "searchDocs": {
+ "message": "문서 검색"
+ },
+ "searchDocsSlash": {
+ "message": "문서 검색 /"
+ },
+ "sortTitle": {
+ "message": "정렬"
+ },
+ "sortRecent": {
+ "message": "최근 변경순"
+ },
+ "sortName": {
+ "message": "이름"
+ },
+ "sortFolder": {
+ "message": "폴더"
+ },
+ "newDocument": {
+ "message": "+ 새 문서"
+ },
+ "browseAll": {
+ "message": "전체 보기"
+ },
+ "reconnectFolders": {
+ "message": "폴더 다시 연결"
+ },
+ "primeIntro": {
+ "message": "Chrome이 곧 묻습니다. 가운데 항목을 선택하세요:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — 다시 연결이 필요한 폴더가 있습니다"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray를 다시 연결해야 합니다"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome이 폴더 권한을 해제했습니다. 복구하기 전까지는 문서를 저장할 때마다 저장 위치를 묻습니다."
+ },
+ "reconnect": {
+ "message": "다시 연결"
+ },
+ "ctxOpenPanel": {
+ "message": "Bento Tray 패널 열기"
+ },
+ "panelEmpty": {
+ "message": "폴더에 아직 Bento 문서가 없습니다."
+ },
+ "noMatches": {
+ "message": "“$1”과(와) 일치하는 항목이 없습니다"
+ },
+ "rowUnplacedTip": {
+ "message": "$1의 문서를 Finder에서 한 번만 열면, 그 폴더 안의 모든 문서를 여기서 열 수 있습니다."
+ },
+ "encrypted": {
+ "message": "암호로 보호됨"
+ },
+ "notSavedYet": {
+ "message": "아직 저장되지 않음"
+ },
+ "fileAccessOffShort": {
+ "message": "로컬 파일 접근이 꺼져 있습니다"
+ },
+ "noFoldersYet": {
+ "message": "아직 폴더가 없습니다"
+ },
+ "foldersNeedReconnect": {
+ "message": "폴더 $1개를 다시 연결해야 합니다"
+ },
+ "statusOneFolder": {
+ "message": "폴더 $1개 · 제자리 저장"
+ },
+ "statusFolders": {
+ "message": "폴더 $1개 · 제자리 저장"
+ },
+ "renewNotOffered": {
+ "message": "Chrome이 복구를 제안하지 않았습니다"
+ },
+ "renewTryAfterRestart": {
+ "message": "Chrome을 다시 시작한 뒤 시도하세요"
+ },
+ "fetchingLatest": {
+ "message": "최신 Bento를 가져오는 중…"
+ },
+ "created": {
+ "message": "$1 만듦"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2은(는) 읽을 수 있지만 아직 열 수 없습니다 — Chrome은 폴더가 디스크의 어디에 있는지 확장 프로그램에 알려주지 않습니다. <b>전체 보기</b>로 한 번에 찾을 수 있습니다."
+ },
+ "andMore": {
+ "message": " 외 $1개"
+ },
+ "agoJustNow": {
+ "message": "방금"
+ },
+ "agoMinutes": {
+ "message": "$1분 전"
+ },
+ "agoHour": {
+ "message": "$1시간 전"
+ },
+ "agoHours": {
+ "message": "$1시간 전"
+ },
+ "agoDay": {
+ "message": "$1일 전"
+ },
+ "agoDays": {
+ "message": "$1일 전"
+ },
+ "searchScope": {
+ "message": "검색은 제목, 파일 이름, 폴더, 그리고 문서 안의 단어까지 살펴봅니다."
+ },
+ "folderEmpty": {
+ "message": "이 폴더에는 아직 아무것도 없습니다"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ 새 문서</b>로 여기에 하나 만드세요."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray는 $1이(가) 디스크의 어디에 있는지 아직 모릅니다. “내 폴더 찾기”를 쓰거나, 그 안의 문서를 Finder에서 한 번 여세요."
+ },
+ "cardRenamedTip": {
+ "message": "$1은(는) 다른 이름으로 저장된 Bento 문서입니다. 여기서 열리지만 저장할 때 위치를 묻습니다 — 제자리 저장은 .bento.html로 끝나는 파일만 인식합니다."
+ },
+ "badgeRenamed": {
+ "message": ".bento.html이 아니라 .html로 되어 있습니다 — 열리지만 저장할 때 위치를 묻습니다."
+ },
+ "menuOpen": {
+ "message": "열기"
+ },
+ "menuDuplicate": {
+ "message": "복제"
+ },
+ "menuRename": {
+ "message": "이름 바꾸기…"
+ },
+ "menuCopyPath": {
+ "message": "경로 복사"
+ },
+ "duplicatedAs": {
+ "message": "$1(으)로 복제했습니다"
+ },
+ "renamePrompt": {
+ "message": "문서 이름 바꾸기"
+ },
+ "renamedTo": {
+ "message": "$1(으)로 이름을 바꿨습니다"
+ },
+ "pathCopied": {
+ "message": "경로를 복사했습니다"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — 아직 열지 않음"
+ },
+ "setupTitle": {
+ "message": "두 가지만 하면 준비 끝"
+ },
+ "setupLead": {
+ "message": "이후로는 더블클릭해서 연 문서에서 ⌘S를 누르면 그 파일에 바로 저장됩니다 — 저장 위치를 묻는 일은 다시 없습니다."
+ },
+ "chooseFolder": {
+ "message": "폴더 선택…"
+ },
+ "setupStep1": {
+ "message": "문서가 있는 폴더를 선택하세요"
+ },
+ "setupStep1Note": {
+ "message": "넓은 폴더 하나면 대개 충분합니다 — 그 안의 모든 것이 포함됩니다."
+ },
+ "setupStep2": {
+ "message": "로컬 파일 접근을 켜세요"
+ },
+ "setupStep2Note": {
+ "message": "<code>chrome://extensions</code> → Bento Tray → <b>파일 URL에 대한 액세스 허용</b>. Chrome은 확장 프로그램이 이 설정을 스스로 켜도록 허용하지 않습니다."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>업그레이드했는데 폴더가 그대로 있을 줄 아셨나요?</b> 압축을 푼 확장 프로그램은 폴더 경로로 식별되므로, 다른 폴더에서 새 사본을 불러오면 별개의 확장 프로그램이 됩니다. 폴더 권한은 여전히 예전 것에 남아 있습니다. 대신 원래 폴더의 파일을 교체하고 <code>chrome://extensions</code>에서 <b>새로고침</b>을 누르세요."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>로컬 파일 접근이 꺼져 있습니다</b> — 켜기 전까지는 제자리 저장이 되지 않습니다. <code>chrome://extensions</code>에서 <b>파일 URL에 대한 액세스 허용</b>을 켜세요."
+ },
+ "noticeLapsed": {
+ "message": "<b>폴더 $1개를 다시 연결해야 합니다.</b> <b>설정</b>에서 다시 연결하고 <b>방문할 때마다 허용</b>을 선택하세요 — 유일하게 유지되는 선택지입니다."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b>은(는) 목록에는 나오지만 아직 열 수 없습니다 — Chrome은 폴더가 디스크의 어디에 있는지 확장 프로그램에 결코 알려주지 않습니다."
+ },
+ "findFolders": {
+ "message": "내 폴더 찾기"
+ },
+ "looking": {
+ "message": "찾는 중…"
+ },
+ "findDeclined": {
+ "message": "<b>괜찮습니다.</b> 대신 $1의 문서를 Finder에서 한 번 열어 보세요 — 이 페이지가 알아챕니다."
+ },
+ "foundFolder": {
+ "message": "폴더 $1개를 찾았습니다"
+ },
+ "foundFolders": {
+ "message": "폴더 $1개를 찾았습니다"
+ },
+ "foundNothing": {
+ "message": "기록에 아직 아무것도 없습니다 — Finder에서 문서를 하나 열어 보세요"
+ },
+ "setFoldersSub": {
+ "message": "여기 있는 문서는 저장 위치를 묻지 않고 파일에 바로 저장됩니다. 폴더는 그 안의 모든 것을 포함합니다."
+ },
+ "noneYet": {
+ "message": "아직 없습니다."
+ },
+ "savesInPlace": {
+ "message": "제자리 저장"
+ },
+ "needsReconnecting": {
+ "message": "다시 연결 필요"
+ },
+ "reconnectTip": {
+ "message": "Chrome이 이 폴더를 복구할지 묻습니다. “허용 안 함”을 누르면 해제되고, 그 뒤로는 다시 묻기까지 재시작 이상을 기다립니다."
+ },
+ "remove": {
+ "message": "제거"
+ },
+ "removeTip": {
+ "message": "접근 권한을 없앱니다. Chrome이 권한을 기억할 수 있으므로, 폴더를 다시 추가해도 묻지 않을 수 있습니다."
+ },
+ "setAccessTitle": {
+ "message": "로컬 파일 접근"
+ },
+ "setAccessSub": {
+ "message": "Chrome은 확장 프로그램이 이 설정을 스스로 켜도록 허용하지 않으며, 이것 없이는 아무것도 동작하지 않습니다."
+ },
+ "stateOn": {
+ "message": "켜짐"
+ },
+ "stateOff": {
+ "message": "꺼짐"
+ },
+ "stateUnknown": {
+ "message": "알 수 없음"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray가 디스크에서 연 페이지를 읽을 수 있습니다."
+ },
+ "accessOffNote": {
+ "message": "chrome://extensions를 열고 Bento Tray를 찾아 “파일 URL에 대한 액세스 허용”을 켜세요."
+ },
+ "accessUnknownNote": {
+ "message": "이 브라우저는 상태를 알려주지 않습니다. 저장할 때 여전히 묻는다면 chrome://extensions에서 확인하세요."
+ },
+ "setVersionTitle": {
+ "message": "버전"
+ },
+ "setVersionUnpacked": {
+ "message": "이 사본은 압축을 풀어 불러왔으므로 Chrome이 절대 업데이트하지 않습니다."
+ },
+ "setVersionStore": {
+ "message": "스토어에서 설치되어 스스로 업데이트됩니다."
+ },
+ "versionAvailable": {
+ "message": "$1을(를) 사용할 수 있습니다"
+ },
+ "versionUpToDate": {
+ "message": "마지막 확인 기준 최신"
+ },
+ "versionManaged": {
+ "message": "브라우저가 최신 상태로 유지합니다"
+ },
+ "getIt": {
+ "message": "받기"
+ },
+ "checkNow": {
+ "message": "지금 확인"
+ },
+ "autoCheckPref": {
+ "message": "<b>브라우저를 시작할 때 새 버전을 확인합니다.</b><br>bento.page에 정적 파일 하나를 요청합니다. 식별자도, 버전 번호도, 문서에 관한 어떤 것도 보내지 않습니다 — 비교는 이곳에서 이루어집니다. 끄면 아무것도 요청하지 않으며, <b>지금 확인</b>은 그대로 동작합니다."
+ },
+ "expectedSha": {
+ "message": "zip의 예상 SHA-256: $1"
+ },
+ "setReachTitle": {
+ "message": "접근 범위"
+ },
+ "setReachSub": {
+ "message": "위의 폴더, 그리고 페이지가 실제로 열린 파일만입니다. 아무것도 업로드하지 않으며 다른 곳은 읽지 않습니다."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1을(를) 사용할 수 있습니다.</b> 이 사본은 압축을 풀어 불러왔으므로 Chrome이 절대 업데이트하지 않습니다."
+ },
+ "updateStep1": {
+ "message": "GitHub에서 내려받으세요"
+ },
+ "updateStep2": {
+ "message": "<b>불러왔던 그 폴더 안의</b> 파일을 교체하세요 — 같은 폴더여야 합니다. 그렇지 않으면 Chrome이 다른 확장 프로그램으로 취급해 허용한 폴더가 따라오지 않습니다"
+ },
+ "updateStep3": {
+ "message": "<code>chrome://extensions</code>를 열고 Bento Tray의 <b>새로고침</b>을 누르세요"
+ },
+ "fetchingApp": {
+ "message": "$1을(를) 가져오는 중…"
+ },
+ "createdIn": {
+ "message": "$3에 $1($2)을(를) 만들었습니다"
+ },
+ "intoFolder": {
+ "message": "$1에"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray가 하는 일"
+ },
+ "helpWhatSub": {
+ "message": "Bento 문서는 자체 편집기를 품은 하나의 HTML 파일입니다. 디스크에서 바로 열면 브라우저가 자기 자신에게 쓰는 것을 허용하지 않으므로, 저장할 때마다 위치를 묻습니다. Bento Tray는 그 질문을 없앱니다."
+ },
+ "tourSaveTitle": {
+ "message": "제자리 저장"
+ },
+ "tourSaveBody": {
+ "message": "⌘S를 누르면 대화상자 없이 열었던 파일에 바로 씁니다. 자동 저장과 제자리 업데이트도 같은 경로를 씁니다."
+ },
+ "tourFindTitle": {
+ "message": "문서 찾기"
+ },
+ "tourFindBody": {
+ "message": "폴더 안의 모든 Bento 문서를 실제 제목과 첫 페이지 그림과 함께 보여줍니다. 검색은 문서 안에 쓰인 내용까지 포함합니다."
+ },
+ "tourSwitchTitle": {
+ "message": "작업하며 전환"
+ },
+ "tourSwitchBody": {
+ "message": "<kbd>Alt</kbd>+<kbd>B</kbd>를 누르거나 문서 안에서 오른쪽 클릭하면 옆에 패널이 열립니다."
+ },
+ "tourNewTitle": {
+ "message": "새로 만들기"
+ },
+ "tourNewBody": {
+ "message": "<b>+ 새 문서</b>는 Slides, Spaces, Dash의 현재 릴리스를 가져와 폴더에 새 문서를 만듭니다."
+ },
+ "helpNeedsTitle": {
+ "message": "필요한 두 가지"
+ },
+ "helpNeedsSub": {
+ "message": "두 가지 모두 이 확장 프로그램이 스스로 처리할 수 없는 일입니다."
+ },
+ "helpFolder": {
+ "message": "폴더"
+ },
+ "helpFolderGranted": {
+ "message": "$1개 허용됨 — 그 안의 문서는 제자리에 저장됩니다"
+ },
+ "helpFolderNone": {
+ "message": "아직 선택하지 않았습니다. 넓은 폴더 하나면 그 안의 모든 것이 포함됩니다."
+ },
+ "helpAccessOff": {
+ "message": "꺼짐. <code>chrome://extensions</code>에서 <b>파일 URL에 대한 액세스 허용</b>을 켜세요 — 어떤 확장 프로그램도 이 설정을 스스로 켤 수 없습니다."
+ },
+ "helpAccessUnknown": {
+ "message": "이 브라우저는 상태를 알려주지 않습니다. 저장할 때 여전히 묻는다면 <code>chrome://extensions</code>에서 확인하세요."
+ },
+ "helpAccessOn": {
+ "message": "켜짐 — Bento Tray가 디스크에서 연 페이지를 읽을 수 있습니다."
+ },
+ "helpNeverTitle": {
+ "message": "결코 하지 않는 일"
+ },
+ "helpNeverSub": {
+ "message": "위의 폴더 안에서만, 그리고 페이지가 실제로 열린 파일만 읽고 씁니다 — 어느 파일인지는 브라우저가 알려주므로 문서가 남의 파일을 지목할 수 없습니다. 문서에 관한 어떤 것도 어디에도 업로드되지 않으며, 이 확장 프로그램에는 업로드할 서버 자체가 없습니다."
+ },
+ "helpAboutTitle": {
+ "message": "정보"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · Bento 프로젝트의 일부 · MIT 라이선스"
+ },
+ "linkSource": {
+ "message": "GitHub 소스"
+ },
+ "linkIssues": {
+ "message": "문제 신고"
+ },
+ "linkReleases": {
+ "message": "릴리스"
+ },
+ "primeMiddle": {
+ "message": "계속 유지되는 항목"
+ },
+ "primeNote": {
+ "message": "나머지 둘도 동작하지만 Chrome이 다시 묻습니다 — 첫 번째는 재시작할 때마다, 마지막은 일정 시간이 지난 뒤에."
+ }
+}
diff --git a/tray/webext/_locales/ms/messages.json b/tray/webext/_locales/ms/messages.json
new file mode 100644
index 00000000..9f424232
--- /dev/null
+++ b/tray/webext/_locales/ms/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Simpan dokumen Bento semula ke fail yang anda buka, tanpa ditanya destinasi."
+ },
+ "navAll": {
+ "message": "Semua dokumen"
+ },
+ "navFolders": {
+ "message": "Folder"
+ },
+ "navHelp": {
+ "message": "Bantuan & perihal"
+ },
+ "navSettings": {
+ "message": "Tetapan"
+ },
+ "addFolder": {
+ "message": "+ Tambah folder…"
+ },
+ "searchDocs": {
+ "message": "Cari dokumen"
+ },
+ "searchDocsSlash": {
+ "message": "Cari dokumen /"
+ },
+ "sortTitle": {
+ "message": "Isih"
+ },
+ "sortRecent": {
+ "message": "Baru diubah"
+ },
+ "sortName": {
+ "message": "Nama"
+ },
+ "sortFolder": {
+ "message": "Folder"
+ },
+ "newDocument": {
+ "message": "+ Dokumen baharu"
+ },
+ "browseAll": {
+ "message": "Layari semua"
+ },
+ "reconnectFolders": {
+ "message": "Sambung semula folder"
+ },
+ "primeIntro": {
+ "message": "Chrome akan bertanya sebentar lagi. Pilih pilihan tengah:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — sebuah folder perlu disambung semula"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray perlu disambung semula"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome menarik balik kebenaran bagi sebuah folder. Sehingga ia dipulihkan, setiap simpanan akan bertanya di mana hendak diletakkan."
+ },
+ "reconnect": {
+ "message": "Sambung semula"
+ },
+ "ctxOpenPanel": {
+ "message": "Buka panel Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "Belum ada dokumen Bento dalam folder anda."
+ },
+ "noMatches": {
+ "message": "Tiada yang sepadan dengan “$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Buka satu dokumen dalam $1 sekali melalui Finder, dan segala-galanya dalam folder itu boleh dibuka dari sini."
+ },
+ "encrypted": {
+ "message": "Dilindungi kata laluan"
+ },
+ "notSavedYet": {
+ "message": "Belum disimpan"
+ },
+ "fileAccessOffShort": {
+ "message": "Akses fail setempat dimatikan"
+ },
+ "noFoldersYet": {
+ "message": "Belum ada folder"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 folder perlu disambung semula"
+ },
+ "statusOneFolder": {
+ "message": "$1 folder · menyimpan di tempatnya"
+ },
+ "statusFolders": {
+ "message": "$1 folder · menyimpan di tempatnya"
+ },
+ "renewNotOffered": {
+ "message": "Chrome tidak menawarkan untuk memulihkannya"
+ },
+ "renewTryAfterRestart": {
+ "message": "Cuba lagi selepas memulakan semula Chrome"
+ },
+ "fetchingLatest": {
+ "message": "Mengambil Bento terkini…"
+ },
+ "created": {
+ "message": "$1 dicipta"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 boleh dibaca tetapi belum boleh dibuka — Chrome tidak memberitahu sambungan di mana sesebuah folder berada pada cakera. <b>Layari semua</b> menemuinya dengan satu klik."
+ },
+ "andMore": {
+ "message": " dan $1 lagi"
+ },
+ "agoJustNow": {
+ "message": "sebentar tadi"
+ },
+ "agoMinutes": {
+ "message": "$1 min lalu"
+ },
+ "agoHour": {
+ "message": "$1 jam lalu"
+ },
+ "agoHours": {
+ "message": "$1 jam lalu"
+ },
+ "agoDay": {
+ "message": "$1 hari lalu"
+ },
+ "agoDays": {
+ "message": "$1 hari lalu"
+ },
+ "searchScope": {
+ "message": "Carian melihat tajuk, nama fail, folder dan perkataan di dalam dokumen."
+ },
+ "folderEmpty": {
+ "message": "Belum ada apa-apa dalam folder ini"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Dokumen baharu</b> meletakkan satu yang baharu di sini."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray belum tahu di mana $1 berada pada cakera. Gunakan “Cari folder saya”, atau buka satu dokumen di dalamnya melalui Finder sekali."
+ },
+ "cardRenamedTip": {
+ "message": "$1 ialah dokumen Bento dengan nama lain. Ia terbuka dari sini, tetapi penyimpanan akan bertanya destinasi — penyimpanan di tempatnya hanya mengenali fail yang berakhir dengan .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Dinamakan .html dan bukan .bento.html — ia terbuka dari sini, tetapi penyimpanan akan bertanya destinasi."
+ },
+ "menuOpen": {
+ "message": "Buka"
+ },
+ "menuDuplicate": {
+ "message": "Duplikasi"
+ },
+ "menuRename": {
+ "message": "Namakan semula…"
+ },
+ "menuCopyPath": {
+ "message": "Salin laluan"
+ },
+ "duplicatedAs": {
+ "message": "Diduplikasi sebagai $1"
+ },
+ "renamePrompt": {
+ "message": "Namakan semula dokumen"
+ },
+ "renamedTo": {
+ "message": "Dinamakan semula kepada $1"
+ },
+ "pathCopied": {
+ "message": "Laluan disalin"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — belum dibuka"
+ },
+ "setupTitle": {
+ "message": "Dua perkara dan anda sedia"
+ },
+ "setupLead": {
+ "message": "Selepas ini, ⌘S pada dokumen yang anda buka dengan klik dua kali akan menulis terus semula ke failnya — tidak pernah lagi ditanya destinasi."
+ },
+ "chooseFolder": {
+ "message": "Pilih folder…"
+ },
+ "setupStep1": {
+ "message": "Pilih folder tempat dokumen anda berada"
+ },
+ "setupStep1Note": {
+ "message": "Satu folder luas biasanya memadai — ia merangkumi segala-galanya di dalamnya."
+ },
+ "setupStep2": {
+ "message": "Hidupkan akses fail setempat"
+ },
+ "setupStep2Note": {
+ "message": "Dalam <code>chrome://extensions</code> → Bento Tray → <b>Benarkan akses kepada URL fail</b>. Chrome tidak membenarkan sambungan menghidupkannya sendiri."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Baru menaik taraf dan menjangka folder anda ada di sini?</b> Sambungan tanpa pakej dikenali melalui laluan foldernya, jadi salinan baharu yang dimuatkan dari folder lain ialah sambungan yang berbeza. Folder anda masih milik yang lama. Sebaliknya, gantikan fail dalam folder asal dan tekan <b>Muat semula</b> dalam <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Akses fail setempat dimatikan</b> — tiada apa-apa disimpan di tempatnya sehingga ia dihidupkan. Hidupkan <b>Benarkan akses kepada URL fail</b> dalam <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 folder perlu disambung semula.</b> Sambung semula dalam <b>Tetapan</b>, dan pilih <b>Benarkan pada setiap lawatan</b> — satu-satunya pilihan yang kekal."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> boleh disenaraikan tetapi belum boleh dibuka — Chrome tidak pernah memberitahu sambungan di mana sesebuah folder berada pada cakera."
+ },
+ "findFolders": {
+ "message": "Cari folder saya"
+ },
+ "looking": {
+ "message": "Mencari…"
+ },
+ "findDeclined": {
+ "message": "<b>Tidak mengapa.</b> Sebaliknya, buka satu dokumen dalam $1 melalui Finder sekali — halaman ini akan perasan."
+ },
+ "foundFolder": {
+ "message": "Menjumpai $1 folder"
+ },
+ "foundFolders": {
+ "message": "Menjumpai $1 folder"
+ },
+ "foundNothing": {
+ "message": "Belum ada apa-apa dalam sejarah — buka satu dokumen melalui Finder"
+ },
+ "setFoldersSub": {
+ "message": "Dokumen di dalamnya disimpan terus semula ke failnya, tanpa ditanya destinasi. Sesebuah folder merangkumi segala-galanya di dalamnya."
+ },
+ "noneYet": {
+ "message": "Belum ada."
+ },
+ "savesInPlace": {
+ "message": "menyimpan di tempatnya"
+ },
+ "needsReconnecting": {
+ "message": "perlu disambung semula"
+ },
+ "reconnectTip": {
+ "message": "Chrome akan bertanya untuk memulihkan folder ini. “Jangan benarkan” melepaskannya, dan selepas itu Chrome menunggu sekurang-kurangnya satu mula semula sebelum bertanya lagi."
+ },
+ "remove": {
+ "message": "Buang"
+ },
+ "removeTip": {
+ "message": "Menarik balik akses. Chrome mungkin masih mengingati kebenaran itu, jadi menambah folder itu semula mungkin tidak bertanya lagi."
+ },
+ "setAccessTitle": {
+ "message": "Akses fail setempat"
+ },
+ "setAccessSub": {
+ "message": "Chrome tidak membenarkan sambungan menghidupkannya sendiri, dan tiada apa-apa berfungsi tanpanya."
+ },
+ "stateOn": {
+ "message": "Hidup"
+ },
+ "stateOff": {
+ "message": "Mati"
+ },
+ "stateUnknown": {
+ "message": "Tidak diketahui"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray boleh membaca halaman yang anda buka dari cakera."
+ },
+ "accessOffNote": {
+ "message": "Buka chrome://extensions, cari Bento Tray, hidupkan “Benarkan akses kepada URL fail”."
+ },
+ "accessUnknownNote": {
+ "message": "Pelayar ini tidak melaporkannya. Jika penyimpanan masih bertanya, periksa dalam chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Versi"
+ },
+ "setVersionUnpacked": {
+ "message": "Salinan ini dimuatkan tanpa pakej, jadi Chrome tidak akan pernah mengemas kininya."
+ },
+ "setVersionStore": {
+ "message": "Dipasang dari kedai, jadi ia mengemas kini dirinya sendiri."
+ },
+ "versionAvailable": {
+ "message": "$1 tersedia"
+ },
+ "versionUpToDate": {
+ "message": "terkini setakat pemeriksaan terakhir"
+ },
+ "versionManaged": {
+ "message": "dikekalkan terkini oleh pelayar"
+ },
+ "getIt": {
+ "message": "Dapatkan"
+ },
+ "checkNow": {
+ "message": "Periksa sekarang"
+ },
+ "autoCheckPref": {
+ "message": "<b>Periksa versi baharu apabila pelayar dimulakan.</b><br>Satu permintaan ke bento.page bagi sebuah fail statik. Ia tidak menghantar pengecam, nombor versi mahupun apa-apa tentang dokumen anda — perbandingan berlaku di sini. Matikan dan tiada apa-apa pernah diminta; <b>Periksa sekarang</b> tetap berfungsi."
+ },
+ "expectedSha": {
+ "message": "SHA-256 dijangka bagi fail zip: $1"
+ },
+ "setReachTitle": {
+ "message": "Apa yang boleh dicapai"
+ },
+ "setReachSub": {
+ "message": "Hanya folder di atas, dan hanya fail asal sesebuah halaman benar-benar dibuka. Tiada apa-apa dimuat naik dan tiada apa-apa dibaca di tempat lain."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 tersedia.</b> Salinan ini dimuatkan tanpa pakej, jadi Chrome tidak akan pernah mengemas kininya."
+ },
+ "updateStep1": {
+ "message": "Muat turunnya dari GitHub"
+ },
+ "updateStep2": {
+ "message": "Gantikan fail <b>dalam folder tempat anda memuatkannya</b> — folder yang sama, jika tidak Chrome menganggapnya sambungan berbeza dan folder yang telah dibenarkan tidak akan ikut serta"
+ },
+ "updateStep3": {
+ "message": "Buka <code>chrome://extensions</code> dan tekan <b>Muat semula</b> pada Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Mengambil $1…"
+ },
+ "createdIn": {
+ "message": "Mencipta $1 ($2) dalam $3"
+ },
+ "intoFolder": {
+ "message": "ke dalam $1"
+ },
+ "helpWhatTitle": {
+ "message": "Apa yang Bento Tray lakukan"
+ },
+ "helpWhatSub": {
+ "message": "Dokumen Bento ialah satu fail HTML yang membawa editornya sendiri. Dibuka terus dari cakera, pelayar tidak membenarkannya menulis semula kepada dirinya sendiri — jadi setiap penyimpanan bertanya di mana hendak diletakkan. Bento Tray menghilangkan soalan itu."
+ },
+ "tourSaveTitle": {
+ "message": "Simpan di tempatnya"
+ },
+ "tourSaveBody": {
+ "message": "⌘S menulis terus semula ke fail yang anda buka, tanpa dialog. Simpan automatik dan kemas kini di tempatnya menempuh laluan yang sama."
+ },
+ "tourFindTitle": {
+ "message": "Cari dokumen anda"
+ },
+ "tourFindBody": {
+ "message": "Setiap dokumen Bento dalam folder anda, dengan tajuk sebenarnya dan gambar halaman pertamanya. Carian merangkumi apa yang tertulis di dalamnya."
+ },
+ "tourSwitchTitle": {
+ "message": "Bertukar sambil bekerja"
+ },
+ "tourSwitchBody": {
+ "message": "Tekan <kbd>Alt</kbd>+<kbd>B</kbd>, atau klik kanan di dalam dokumen, untuk panel di sebelahnya."
+ },
+ "tourNewTitle": {
+ "message": "Cipta yang baharu"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Dokumen baharu</b> mengambil keluaran terkini Slides, Spaces atau Dash dan meletakkan dokumen baharu dalam folder anda."
+ },
+ "helpNeedsTitle": {
+ "message": "Apa yang diperlukan daripada anda"
+ },
+ "helpNeedsSub": {
+ "message": "Dua perkara, kedua-duanya di luar kuasa sambungan ini untuk mengaturnya."
+ },
+ "helpFolder": {
+ "message": "Sebuah folder"
+ },
+ "helpFolderGranted": {
+ "message": "$1 dibenarkan — dokumen di dalamnya disimpan di tempatnya"
+ },
+ "helpFolderNone": {
+ "message": "Belum dipilih. Satu folder luas merangkumi segala-galanya di dalamnya."
+ },
+ "helpAccessOff": {
+ "message": "Mati. Hidupkan <b>Benarkan akses kepada URL fail</b> dalam <code>chrome://extensions</code> — tiada sambungan boleh menghidupkannya sendiri."
+ },
+ "helpAccessUnknown": {
+ "message": "Pelayar ini tidak melaporkannya. Jika penyimpanan masih bertanya, periksa dalam <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Hidup — Bento Tray boleh membaca halaman yang anda buka dari cakera."
+ },
+ "helpNeverTitle": {
+ "message": "Apa yang ia tidak pernah lakukan"
+ },
+ "helpNeverSub": {
+ "message": "Ia membaca dan menulis hanya dalam folder di atas, dan hanya fail asal sesebuah halaman benar-benar dibuka — pelayar memberitahu yang mana, jadi sesebuah dokumen tidak boleh menamakan fail milik orang lain. Tiada apa-apa tentang dokumen anda dimuat naik ke mana-mana, dan sambungan ini tidak mempunyai pelayan untuk memuat naiknya."
+ },
+ "helpAboutTitle": {
+ "message": "Perihal"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · sebahagian daripada projek Bento · berlesen MIT"
+ },
+ "linkSource": {
+ "message": "Sumber di GitHub"
+ },
+ "linkIssues": {
+ "message": "Laporkan masalah"
+ },
+ "linkReleases": {
+ "message": "Keluaran"
+ },
+ "primeMiddle": {
+ "message": "yang kekal"
+ },
+ "primeNote": {
+ "message": "Dua yang lain juga berfungsi, tetapi Chrome akan bertanya lagi — setiap kali mula semula bagi yang pertama, dan selepas menunggu bagi yang terakhir."
+ }
+}
diff --git a/tray/webext/_locales/nb/messages.json b/tray/webext/_locales/nb/messages.json
new file mode 100644
index 00000000..74986b46
--- /dev/null
+++ b/tray/webext/_locales/nb/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Lagre et Bento-dokument tilbake i filen du åpnet, uten å bli spurt om hvor."
+ },
+ "navAll": {
+ "message": "Alle dokumenter"
+ },
+ "navFolders": {
+ "message": "Mapper"
+ },
+ "navHelp": {
+ "message": "Hjelp og om"
+ },
+ "navSettings": {
+ "message": "Innstillinger"
+ },
+ "addFolder": {
+ "message": "+ Legg til en mappe…"
+ },
+ "searchDocs": {
+ "message": "Søk i dokumenter"
+ },
+ "searchDocsSlash": {
+ "message": "Søk i dokumenter /"
+ },
+ "sortTitle": {
+ "message": "Sorter"
+ },
+ "sortRecent": {
+ "message": "Sist endret"
+ },
+ "sortName": {
+ "message": "Navn"
+ },
+ "sortFolder": {
+ "message": "Mappe"
+ },
+ "newDocument": {
+ "message": "+ Nytt dokument"
+ },
+ "browseAll": {
+ "message": "Vis alle"
+ },
+ "reconnectFolders": {
+ "message": "Koble til mapper på nytt"
+ },
+ "primeIntro": {
+ "message": "Chrome spør straks. Velg det midterste alternativet:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — en mappe må kobles til på nytt"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray må kobles til på nytt"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome har trukket tilbake tillatelsen til en mappe. Til den er gjenopprettet, spør hver lagring hvor filen skal ligge."
+ },
+ "reconnect": {
+ "message": "Koble til på nytt"
+ },
+ "ctxOpenPanel": {
+ "message": "Åpne Bento Tray-panelet"
+ },
+ "panelEmpty": {
+ "message": "Ingen Bento-dokumenter i mappene dine ennå."
+ },
+ "noMatches": {
+ "message": "Ingenting samsvarer med «$1»"
+ },
+ "rowUnplacedTip": {
+ "message": "Åpne ett dokument i $1 én gang fra Finder, så kan alt i den mappen åpnes herfra."
+ },
+ "encrypted": {
+ "message": "Passordbeskyttet"
+ },
+ "notSavedYet": {
+ "message": "Ikke lagret ennå"
+ },
+ "fileAccessOffShort": {
+ "message": "Tilgang til lokale filer er av"
+ },
+ "noFoldersYet": {
+ "message": "Ingen mapper ennå"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 mappe må kobles til på nytt"
+ },
+ "statusOneFolder": {
+ "message": "$1 mappe · lagrer på stedet"
+ },
+ "statusFolders": {
+ "message": "$1 mapper · lagrer på stedet"
+ },
+ "renewNotOffered": {
+ "message": "Chrome tilbød ikke å gjenopprette den"
+ },
+ "renewTryAfterRestart": {
+ "message": "Prøv igjen etter å ha startet Chrome på nytt"
+ },
+ "fetchingLatest": {
+ "message": "Henter nyeste Bento…"
+ },
+ "created": {
+ "message": "$1 opprettet"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 kan leses, men ikke åpnes ennå — Chrome forteller ikke en utvidelse hvor en mappe ligger på disken. <b>Vis alle</b> finner dem med ett klikk."
+ },
+ "andMore": {
+ "message": " og $1 til"
+ },
+ "agoJustNow": {
+ "message": "akkurat nå"
+ },
+ "agoMinutes": {
+ "message": "for $1 min siden"
+ },
+ "agoHour": {
+ "message": "for $1 time siden"
+ },
+ "agoHours": {
+ "message": "for $1 timer siden"
+ },
+ "agoDay": {
+ "message": "for $1 dag siden"
+ },
+ "agoDays": {
+ "message": "for $1 dager siden"
+ },
+ "searchScope": {
+ "message": "Søket ser på titler, filnavn, mapper og ordene inne i dokumentene."
+ },
+ "folderEmpty": {
+ "message": "Ingenting i denne mappen ennå"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Nytt dokument</b> legger et ferskt her."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray vet ikke hvor $1 ligger på disken ennå. Bruk «Finn mappene mine», eller åpne et dokument derfra i Finder én gang."
+ },
+ "cardRenamedTip": {
+ "message": "$1 er et Bento-dokument under et annet navn. Det åpnes herfra, men lagring spør etter et sted — lagring på stedet gjenkjenner bare filer som slutter på .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Heter .html i stedet for .bento.html — det åpnes herfra, men lagring spør etter et sted."
+ },
+ "menuOpen": {
+ "message": "Åpne"
+ },
+ "menuDuplicate": {
+ "message": "Dupliser"
+ },
+ "menuRename": {
+ "message": "Gi nytt navn…"
+ },
+ "menuCopyPath": {
+ "message": "Kopier sti"
+ },
+ "duplicatedAs": {
+ "message": "Duplisert som $1"
+ },
+ "renamePrompt": {
+ "message": "Gi dokumentet nytt navn"
+ },
+ "renamedTo": {
+ "message": "Fikk navnet $1"
+ },
+ "pathCopied": {
+ "message": "Sti kopiert"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — ikke åpnet ennå"
+ },
+ "setupTitle": {
+ "message": "To ting, så er du klar"
+ },
+ "setupLead": {
+ "message": "Etter dette skriver ⌘S i et dokument du åpnet med dobbeltklikk rett tilbake til filen — aldri mer spørsmål om hvor."
+ },
+ "chooseFolder": {
+ "message": "Velg en mappe…"
+ },
+ "setupStep1": {
+ "message": "Velg mappen dokumentene dine ligger i"
+ },
+ "setupStep1Note": {
+ "message": "Én bred mappe holder som regel — den dekker alt inni."
+ },
+ "setupStep2": {
+ "message": "Slå på tilgang til lokale filer"
+ },
+ "setupStep2Note": {
+ "message": "I <code>chrome://extensions</code> → Bento Tray → <b>Tillat tilgang til fil-URL-er</b>. Chrome lar ikke en utvidelse slå dette på selv."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Oppgradert og ventet å finne mappene dine her?</b> En utpakket utvidelse identifiseres av mappestien sin, så en ny kopi lastet fra en annen mappe blir en annen utvidelse. Mappene dine hører fortsatt til den gamle. Bytt heller ut filene i den opprinnelige mappen og trykk <b>Last inn på nytt</b> i <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Tilgang til lokale filer er av</b> — ingenting lagres på stedet før den er på. Slå på <b>Tillat tilgang til fil-URL-er</b> i <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 mappe må kobles til på nytt.</b> Koble den til igjen under <b>Innstillinger</b>, og velg <b>Tillat ved hvert besøk</b> — det eneste alternativet som varer."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> kan vises i listen, men ikke åpnes ennå — Chrome forteller aldri en utvidelse hvor en mappe ligger på disken."
+ },
+ "findFolders": {
+ "message": "Finn mappene mine"
+ },
+ "looking": {
+ "message": "Leter…"
+ },
+ "findDeclined": {
+ "message": "<b>Helt greit.</b> Åpne heller et dokument i $1 fra Finder én gang — denne siden merker det."
+ },
+ "foundFolder": {
+ "message": "Fant $1 mappe"
+ },
+ "foundFolders": {
+ "message": "Fant $1 mapper"
+ },
+ "foundNothing": {
+ "message": "Ingenting i loggen ennå — åpne ett dokument fra Finder"
+ },
+ "setFoldersSub": {
+ "message": "Dokumenter i disse lagres rett tilbake til filen, uten spørsmål om hvor. En mappe dekker alt inni."
+ },
+ "noneYet": {
+ "message": "Ingen ennå."
+ },
+ "savesInPlace": {
+ "message": "lagrer på stedet"
+ },
+ "needsReconnecting": {
+ "message": "må kobles til på nytt"
+ },
+ "reconnectTip": {
+ "message": "Chrome spør om denne mappen kan gjenopprettes. «Ikke tillat» slipper den, og deretter venter Chrome minst en omstart før den spør igjen."
+ },
+ "remove": {
+ "message": "Fjern"
+ },
+ "removeTip": {
+ "message": "Fjerner tilgangen. Chrome kan fortsatt huske tillatelsen, så å legge mappen til igjen spør kanskje ikke."
+ },
+ "setAccessTitle": {
+ "message": "Tilgang til lokale filer"
+ },
+ "setAccessSub": {
+ "message": "Chrome lar ikke en utvidelse slå dette på selv, og ingenting virker uten."
+ },
+ "stateOn": {
+ "message": "På"
+ },
+ "stateOff": {
+ "message": "Av"
+ },
+ "stateUnknown": {
+ "message": "Ukjent"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray kan lese sider du har åpnet fra disken."
+ },
+ "accessOffNote": {
+ "message": "Åpne chrome://extensions, finn Bento Tray og slå på «Tillat tilgang til fil-URL-er»."
+ },
+ "accessUnknownNote": {
+ "message": "Denne nettleseren oppgir det ikke. Hvis lagring fortsatt spør, sjekk det i chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Versjon"
+ },
+ "setVersionUnpacked": {
+ "message": "Denne kopien ble lastet utpakket, så Chrome oppdaterer den aldri."
+ },
+ "setVersionStore": {
+ "message": "Installert fra butikken, så den oppdaterer seg selv."
+ },
+ "versionAvailable": {
+ "message": "$1 er tilgjengelig"
+ },
+ "versionUpToDate": {
+ "message": "oppdatert ved siste sjekk"
+ },
+ "versionManaged": {
+ "message": "holdes oppdatert av nettleseren"
+ },
+ "getIt": {
+ "message": "Hent den"
+ },
+ "checkNow": {
+ "message": "Sjekk nå"
+ },
+ "autoCheckPref": {
+ "message": "<b>Se etter en ny versjon når nettleseren starter.</b><br>Én forespørsel til bento.page om en statisk fil. Den sender ingen identifikatorer, ingen versjonsnummer og ingenting om dokumentene dine — sammenligningen skjer her. Slå den av, og ingenting blir noen gang forespurt; <b>Sjekk nå</b> virker fortsatt."
+ },
+ "expectedSha": {
+ "message": "Forventet SHA-256 for zip-filen: $1"
+ },
+ "setReachTitle": {
+ "message": "Hva dette når"
+ },
+ "setReachSub": {
+ "message": "Bare mappene over, og bare filen en side faktisk ble åpnet fra. Ingenting lastes opp, og ingenting leses andre steder."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 er tilgjengelig.</b> Denne kopien ble lastet utpakket, så Chrome oppdaterer den aldri."
+ },
+ "updateStep1": {
+ "message": "Last den ned fra GitHub"
+ },
+ "updateStep2": {
+ "message": "Bytt ut filene <b>i mappen du lastet den fra</b> — samme mappe, ellers behandler Chrome den som en annen utvidelse, og mappene du har gitt tilgang til følger ikke med"
+ },
+ "updateStep3": {
+ "message": "Åpne <code>chrome://extensions</code> og trykk <b>Last inn på nytt</b> på Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Henter $1…"
+ },
+ "createdIn": {
+ "message": "Opprettet $1 ($2) i $3"
+ },
+ "intoFolder": {
+ "message": "i $1"
+ },
+ "helpWhatTitle": {
+ "message": "Hva Bento Tray gjør"
+ },
+ "helpWhatSub": {
+ "message": "Et Bento-dokument er én HTML-fil som bærer sin egen redigerer. Åpnet rett fra disken lar ikke en nettleser den skrive tilbake til seg selv — så hver lagring spør hvor filen skal ligge. Bento Tray fjerner det spørsmålet."
+ },
+ "tourSaveTitle": {
+ "message": "Lagre på stedet"
+ },
+ "tourSaveBody": {
+ "message": "⌘S skriver rett tilbake til filen du åpnet, uten dialog. Autolagring og oppdateringer på stedet går samme vei."
+ },
+ "tourFindTitle": {
+ "message": "Finn dokumentene dine"
+ },
+ "tourFindBody": {
+ "message": "Alle Bento-dokumenter i mappene dine, med sin virkelige tittel og et bilde av første side. Søket dekker også det som står inni dem."
+ },
+ "tourSwitchTitle": {
+ "message": "Bytt mens du jobber"
+ },
+ "tourSwitchBody": {
+ "message": "Trykk <kbd>Alt</kbd>+<kbd>B</kbd>, eller høyreklikk inne i et dokument, for et panel ved siden av."
+ },
+ "tourNewTitle": {
+ "message": "Lag et nytt"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Nytt dokument</b> henter gjeldende utgave av Slides, Spaces eller Dash og legger et ferskt dokument i mappen din."
+ },
+ "helpNeedsTitle": {
+ "message": "Hva den trenger fra deg"
+ },
+ "helpNeedsSub": {
+ "message": "To ting, begge utenfor denne utvidelsens makt til å ordne."
+ },
+ "helpFolder": {
+ "message": "En mappe"
+ },
+ "helpFolderGranted": {
+ "message": "$1 gitt tilgang — dokumenter i dem lagres på stedet"
+ },
+ "helpFolderNone": {
+ "message": "Ikke valgt ennå. Én bred mappe dekker alt inni."
+ },
+ "helpAccessOff": {
+ "message": "Av. Slå på <b>Tillat tilgang til fil-URL-er</b> i <code>chrome://extensions</code> — ingen utvidelse kan slå dette på selv."
+ },
+ "helpAccessUnknown": {
+ "message": "Denne nettleseren oppgir det ikke. Hvis lagring fortsatt spør, sjekk det i <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "På — Bento Tray kan lese sider du har åpnet fra disken."
+ },
+ "helpNeverTitle": {
+ "message": "Hva den aldri gjør"
+ },
+ "helpNeverSub": {
+ "message": "Den leser og skriver bare inne i mappene over, og bare filen en side faktisk ble åpnet fra — nettleseren sier hvilken, så et dokument kan ikke peke ut andres fil. Ingenting om dokumentene dine lastes opp noe sted, og utvidelsen har ingen tjener å laste dem opp til."
+ },
+ "helpAboutTitle": {
+ "message": "Om"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · del av Bento-prosjektet · MIT-lisensiert"
+ },
+ "linkSource": {
+ "message": "Kildekode på GitHub"
+ },
+ "linkIssues": {
+ "message": "Meld fra om et problem"
+ },
+ "linkReleases": {
+ "message": "Utgivelser"
+ },
+ "primeMiddle": {
+ "message": "det som varer"
+ },
+ "primeNote": {
+ "message": "De to andre virker også, men Chrome spør igjen — ved hver omstart for det første, og etter en ventetid for det siste."
+ }
+}
diff --git a/tray/webext/_locales/nl/messages.json b/tray/webext/_locales/nl/messages.json
new file mode 100644
index 00000000..46a2c3ec
--- /dev/null
+++ b/tray/webext/_locales/nl/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Sla een Bento-document terug op in het bestand dat je hebt geopend, zonder te vragen waar."
+ },
+ "navAll": {
+ "message": "Alle documenten"
+ },
+ "navFolders": {
+ "message": "Mappen"
+ },
+ "navHelp": {
+ "message": "Help en info"
+ },
+ "navSettings": {
+ "message": "Instellingen"
+ },
+ "addFolder": {
+ "message": "+ Map toevoegen…"
+ },
+ "searchDocs": {
+ "message": "Documenten zoeken"
+ },
+ "searchDocsSlash": {
+ "message": "Documenten zoeken /"
+ },
+ "sortTitle": {
+ "message": "Sorteren"
+ },
+ "sortRecent": {
+ "message": "Onlangs gewijzigd"
+ },
+ "sortName": {
+ "message": "Naam"
+ },
+ "sortFolder": {
+ "message": "Map"
+ },
+ "newDocument": {
+ "message": "+ Nieuw document"
+ },
+ "browseAll": {
+ "message": "Alles bekijken"
+ },
+ "reconnectFolders": {
+ "message": "Mappen opnieuw verbinden"
+ },
+ "primeIntro": {
+ "message": "Chrome vraagt het zo. Kies de middelste optie:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — een map moet opnieuw worden verbonden"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray moet opnieuw worden verbonden"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome heeft de toestemming voor een map ingetrokken. Tot die hersteld is, vraagt elk opslaan waar het bestand heen moet."
+ },
+ "reconnect": {
+ "message": "Opnieuw verbinden"
+ },
+ "ctxOpenPanel": {
+ "message": "Bento Tray-paneel openen"
+ },
+ "panelEmpty": {
+ "message": "Nog geen Bento-documenten in je mappen."
+ },
+ "noMatches": {
+ "message": "Niets komt overeen met “$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Open één document in $1 één keer vanuit Finder, en alles in die map is hiervandaan te openen."
+ },
+ "encrypted": {
+ "message": "Beveiligd met wachtwoord"
+ },
+ "notSavedYet": {
+ "message": "Nog niet opgeslagen"
+ },
+ "fileAccessOffShort": {
+ "message": "Toegang tot lokale bestanden staat uit"
+ },
+ "noFoldersYet": {
+ "message": "Nog geen mappen"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 map moet opnieuw worden verbonden"
+ },
+ "statusOneFolder": {
+ "message": "$1 map · slaat ter plekke op"
+ },
+ "statusFolders": {
+ "message": "$1 mappen · slaan ter plekke op"
+ },
+ "renewNotOffered": {
+ "message": "Chrome bood niet aan om die te herstellen"
+ },
+ "renewTryAfterRestart": {
+ "message": "Probeer het opnieuw nadat je Chrome hebt herstart"
+ },
+ "fetchingLatest": {
+ "message": "De nieuwste Bento ophalen…"
+ },
+ "created": {
+ "message": "$1 aangemaakt"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 kan wel worden gelezen, maar nog niet geopend — Chrome vertelt een extensie niet waar een map op de schijf staat. <b>Alles bekijken</b> vindt ze met één klik."
+ },
+ "andMore": {
+ "message": " en nog $1"
+ },
+ "agoJustNow": {
+ "message": "zojuist"
+ },
+ "agoMinutes": {
+ "message": "$1 min geleden"
+ },
+ "agoHour": {
+ "message": "$1 uur geleden"
+ },
+ "agoHours": {
+ "message": "$1 uur geleden"
+ },
+ "agoDay": {
+ "message": "$1 dag geleden"
+ },
+ "agoDays": {
+ "message": "$1 dagen geleden"
+ },
+ "searchScope": {
+ "message": "Zoeken kijkt naar titels, bestandsnamen, mappen en de woorden in documenten."
+ },
+ "folderEmpty": {
+ "message": "Nog niets in deze map"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Nieuw document</b> zet er een verse neer."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray weet nog niet waar $1 op de schijf staat. Gebruik “Mijn mappen zoeken”, of open er één keer een document uit vanuit Finder."
+ },
+ "cardRenamedTip": {
+ "message": "$1 is een Bento-document onder een andere naam. Het opent hiervandaan, maar bij opslaan wordt om een bestemming gevraagd — ter plekke opslaan herkent alleen bestanden die op .bento.html eindigen."
+ },
+ "badgeRenamed": {
+ "message": "Heet .html in plaats van .bento.html — het opent hiervandaan, maar bij opslaan wordt om een bestemming gevraagd."
+ },
+ "menuOpen": {
+ "message": "Openen"
+ },
+ "menuDuplicate": {
+ "message": "Dupliceren"
+ },
+ "menuRename": {
+ "message": "Naam wijzigen…"
+ },
+ "menuCopyPath": {
+ "message": "Pad kopiëren"
+ },
+ "duplicatedAs": {
+ "message": "Gedupliceerd als $1"
+ },
+ "renamePrompt": {
+ "message": "Documentnaam wijzigen"
+ },
+ "renamedTo": {
+ "message": "Hernoemd naar $1"
+ },
+ "pathCopied": {
+ "message": "Pad gekopieerd"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — nog niet geopend"
+ },
+ "setupTitle": {
+ "message": "Twee dingen en je bent klaar"
+ },
+ "setupLead": {
+ "message": "Daarna schrijft ⌘S in een document dat je met dubbelklikken hebt geopend meteen terug naar het bestand — nooit meer de vraag waar het heen moet."
+ },
+ "chooseFolder": {
+ "message": "Map kiezen…"
+ },
+ "setupStep1": {
+ "message": "Kies de map waar je documenten staan"
+ },
+ "setupStep1Note": {
+ "message": "Eén ruime map is meestal genoeg — die dekt alles wat erin zit."
+ },
+ "setupStep2": {
+ "message": "Zet toegang tot lokale bestanden aan"
+ },
+ "setupStep2Note": {
+ "message": "In <code>chrome://extensions</code> → Bento Tray → <b>Toegang tot bestands-URL's toestaan</b>. Chrome laat een extensie dit niet zelf aanzetten."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Bijgewerkt en verwachtte je je mappen hier terug?</b> Een uitgepakte extensie wordt herkend aan haar mappad, dus een nieuwe kopie uit een andere map is voor Chrome een andere extensie. Je mappen horen nog bij de oude. Vervang in plaats daarvan de bestanden in de oorspronkelijke map en druk op <b>Opnieuw laden</b> in <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Toegang tot lokale bestanden staat uit</b> — er wordt niets ter plekke opgeslagen zolang dat zo is. Zet <b>Toegang tot bestands-URL's toestaan</b> aan in <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 map moet opnieuw worden verbonden.</b> Verbind die opnieuw bij <b>Instellingen</b> en kies <b>Toestaan bij elk bezoek</b> — de enige optie die blijft gelden."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> kan wel worden getoond, maar nog niet geopend — Chrome vertelt een extensie nooit waar een map op de schijf staat."
+ },
+ "findFolders": {
+ "message": "Mijn mappen zoeken"
+ },
+ "looking": {
+ "message": "Zoeken…"
+ },
+ "findDeclined": {
+ "message": "<b>Geen probleem.</b> Open dan één keer een document in $1 vanuit Finder — deze pagina merkt het."
+ },
+ "foundFolder": {
+ "message": "$1 map gevonden"
+ },
+ "foundFolders": {
+ "message": "$1 mappen gevonden"
+ },
+ "foundNothing": {
+ "message": "Nog niets in de geschiedenis — open één document vanuit Finder"
+ },
+ "setFoldersSub": {
+ "message": "Documenten hierin worden meteen terug naar het bestand opgeslagen, zonder te vragen waar. Een map dekt alles wat erin zit."
+ },
+ "noneYet": {
+ "message": "Nog geen."
+ },
+ "savesInPlace": {
+ "message": "slaat ter plekke op"
+ },
+ "needsReconnecting": {
+ "message": "moet opnieuw worden verbonden"
+ },
+ "reconnectTip": {
+ "message": "Chrome vraagt of deze map hersteld mag worden. “Niet toestaan” laat hem vallen, en daarna wacht Chrome minstens een herstart voordat het opnieuw vraagt."
+ },
+ "remove": {
+ "message": "Verwijderen"
+ },
+ "removeTip": {
+ "message": "Neemt de toegang weg. Chrome kan de toestemming onthouden, dus bij opnieuw toevoegen wordt misschien niets gevraagd."
+ },
+ "setAccessTitle": {
+ "message": "Toegang tot lokale bestanden"
+ },
+ "setAccessSub": {
+ "message": "Chrome laat een extensie dit niet zelf aanzetten, en zonder dit werkt er niets."
+ },
+ "stateOn": {
+ "message": "Aan"
+ },
+ "stateOff": {
+ "message": "Uit"
+ },
+ "stateUnknown": {
+ "message": "Onbekend"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray kan pagina's lezen die je vanaf schijf hebt geopend."
+ },
+ "accessOffNote": {
+ "message": "Open chrome://extensions, zoek Bento Tray en zet “Toegang tot bestands-URL's toestaan” aan."
+ },
+ "accessUnknownNote": {
+ "message": "Deze browser meldt het niet. Als opslaan nog steeds vraagt, controleer het in chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Versie"
+ },
+ "setVersionUnpacked": {
+ "message": "Deze kopie is uitgepakt geladen, dus Chrome werkt hem nooit bij."
+ },
+ "setVersionStore": {
+ "message": "Geïnstalleerd uit de store, dus hij werkt zichzelf bij."
+ },
+ "versionAvailable": {
+ "message": "$1 is beschikbaar"
+ },
+ "versionUpToDate": {
+ "message": "actueel sinds de laatste controle"
+ },
+ "versionManaged": {
+ "message": "wordt door de browser actueel gehouden"
+ },
+ "getIt": {
+ "message": "Ophalen"
+ },
+ "checkNow": {
+ "message": "Nu controleren"
+ },
+ "autoCheckPref": {
+ "message": "<b>Controleer op een nieuwe versie bij het starten van de browser.</b><br>Eén verzoek aan bento.page voor een statisch bestand. Het stuurt geen identificatiegegevens, geen versienummer en niets over je documenten — de vergelijking gebeurt hier. Zet het uit en er wordt nooit iets opgevraagd; <b>Nu controleren</b> blijft werken."
+ },
+ "expectedSha": {
+ "message": "Verwachte SHA-256 van de zip: $1"
+ },
+ "setReachTitle": {
+ "message": "Waar dit bij kan"
+ },
+ "setReachSub": {
+ "message": "Alleen de mappen hierboven, en alleen het bestand waaruit een pagina daadwerkelijk is geopend. Er wordt niets geüpload en nergens anders iets gelezen."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 is beschikbaar.</b> Deze kopie is uitgepakt geladen, dus Chrome werkt hem nooit bij."
+ },
+ "updateStep1": {
+ "message": "Download hem van GitHub"
+ },
+ "updateStep2": {
+ "message": "Vervang de bestanden <b>in de map waaruit je hem hebt geladen</b> — dezelfde map, anders ziet Chrome het als een andere extensie en gaan je toegestane mappen niet mee"
+ },
+ "updateStep3": {
+ "message": "Open <code>chrome://extensions</code> en druk op <b>Opnieuw laden</b> bij Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "$1 ophalen…"
+ },
+ "createdIn": {
+ "message": "$1 ($2) aangemaakt in $3"
+ },
+ "intoFolder": {
+ "message": "in $1"
+ },
+ "helpWhatTitle": {
+ "message": "Wat Bento Tray doet"
+ },
+ "helpWhatSub": {
+ "message": "Een Bento-document is één HTML-bestand dat zijn eigen editor meedraagt. Rechtstreeks vanaf schijf geopend laat een browser het niet naar zichzelf terugschrijven — dus vraagt elk opslaan waar het heen moet. Bento Tray haalt die vraag weg."
+ },
+ "tourSaveTitle": {
+ "message": "Ter plekke opslaan"
+ },
+ "tourSaveBody": {
+ "message": "⌘S schrijft meteen terug naar het bestand dat je hebt geopend, zonder venster. Automatisch opslaan en updates ter plekke gaan dezelfde weg."
+ },
+ "tourFindTitle": {
+ "message": "Je documenten vinden"
+ },
+ "tourFindBody": {
+ "message": "Elk Bento-document in je mappen, met zijn echte titel en een plaatje van de eerste pagina. Zoeken kijkt ook naar wat erin geschreven staat."
+ },
+ "tourSwitchTitle": {
+ "message": "Wisselen tijdens het werken"
+ },
+ "tourSwitchBody": {
+ "message": "Druk op <kbd>Alt</kbd>+<kbd>B</kbd>, of klik met rechts in een document, voor een paneel ernaast."
+ },
+ "tourNewTitle": {
+ "message": "Een nieuwe maken"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Nieuw document</b> haalt de huidige release van Slides, Spaces of Dash op en zet een vers document in je map."
+ },
+ "helpNeedsTitle": {
+ "message": "Wat het van je nodig heeft"
+ },
+ "helpNeedsSub": {
+ "message": "Twee dingen, allebei buiten de macht van deze extensie om te regelen."
+ },
+ "helpFolder": {
+ "message": "Een map"
+ },
+ "helpFolderGranted": {
+ "message": "$1 toegestaan — documenten daarin worden ter plekke opgeslagen"
+ },
+ "helpFolderNone": {
+ "message": "Nog niet gekozen. Eén ruime map dekt alles wat erin zit."
+ },
+ "helpAccessOff": {
+ "message": "Uit. Zet <b>Toegang tot bestands-URL's toestaan</b> aan in <code>chrome://extensions</code> — geen enkele extensie kan dit zelf aanzetten."
+ },
+ "helpAccessUnknown": {
+ "message": "Deze browser meldt het niet. Als opslaan nog steeds vraagt, controleer het in <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Aan — Bento Tray kan pagina's lezen die je vanaf schijf hebt geopend."
+ },
+ "helpNeverTitle": {
+ "message": "Wat het nooit doet"
+ },
+ "helpNeverSub": {
+ "message": "Het leest en schrijft alleen binnen de mappen hierboven, en alleen het bestand waaruit een pagina daadwerkelijk is geopend — de browser zegt welk, dus een document kan niet iemand anders' bestand aanwijzen. Er wordt niets over je documenten geüpload, en de extensie heeft geen server om ze naartoe te sturen."
+ },
+ "helpAboutTitle": {
+ "message": "Over"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · onderdeel van het Bento-project · MIT-licentie"
+ },
+ "linkSource": {
+ "message": "Broncode op GitHub"
+ },
+ "linkIssues": {
+ "message": "Een probleem melden"
+ },
+ "linkReleases": {
+ "message": "Releases"
+ },
+ "primeMiddle": {
+ "message": "degene die blijft gelden"
+ },
+ "primeNote": {
+ "message": "De andere twee werken ook, maar dan vraagt Chrome het opnieuw — bij de eerste elke herstart, bij de laatste na een wachttijd."
+ }
+}
diff --git a/tray/webext/_locales/pl/messages.json b/tray/webext/_locales/pl/messages.json
new file mode 100644
index 00000000..7c55e975
--- /dev/null
+++ b/tray/webext/_locales/pl/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Zapisz dokument Bento z powrotem do otwartego pliku, bez pytania o miejsce docelowe."
+ },
+ "navAll": {
+ "message": "Wszystkie dokumenty"
+ },
+ "navFolders": {
+ "message": "Foldery"
+ },
+ "navHelp": {
+ "message": "Pomoc i informacje"
+ },
+ "navSettings": {
+ "message": "Ustawienia"
+ },
+ "addFolder": {
+ "message": "+ Dodaj folder…"
+ },
+ "searchDocs": {
+ "message": "Szukaj w dokumentach"
+ },
+ "searchDocsSlash": {
+ "message": "Szukaj w dokumentach /"
+ },
+ "sortTitle": {
+ "message": "Sortuj"
+ },
+ "sortRecent": {
+ "message": "Ostatnio zmienione"
+ },
+ "sortName": {
+ "message": "Nazwa"
+ },
+ "sortFolder": {
+ "message": "Folder"
+ },
+ "newDocument": {
+ "message": "+ Nowy dokument"
+ },
+ "browseAll": {
+ "message": "Przeglądaj wszystkie"
+ },
+ "reconnectFolders": {
+ "message": "Połącz foldery ponownie"
+ },
+ "primeIntro": {
+ "message": "Chrome zaraz zapyta. Wybierz środkową opcję:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — folder wymaga ponownego połączenia"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray wymaga ponownego połączenia"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome cofnął uprawnienie do folderu. Dopóki nie zostanie przywrócone, każdy zapis będzie pytał o miejsce docelowe."
+ },
+ "reconnect": {
+ "message": "Połącz ponownie"
+ },
+ "ctxOpenPanel": {
+ "message": "Otwórz panel Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "W Twoich folderach nie ma jeszcze dokumentów Bento."
+ },
+ "noMatches": {
+ "message": "Nic nie pasuje do „$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Otwórz raz dowolny dokument w $1 z Findera, a wszystko w tym folderze będzie można otwierać stąd."
+ },
+ "encrypted": {
+ "message": "Chroniony hasłem"
+ },
+ "notSavedYet": {
+ "message": "Jeszcze niezapisany"
+ },
+ "fileAccessOffShort": {
+ "message": "Dostęp do plików lokalnych jest wyłączony"
+ },
+ "noFoldersYet": {
+ "message": "Brak folderów"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 folder wymaga ponownego połączenia"
+ },
+ "statusOneFolder": {
+ "message": "$1 folder · zapis w miejscu"
+ },
+ "statusFolders": {
+ "message": "$1 foldery · zapis w miejscu"
+ },
+ "renewNotOffered": {
+ "message": "Chrome nie zaproponował przywrócenia"
+ },
+ "renewTryAfterRestart": {
+ "message": "Spróbuj ponownie po ponownym uruchomieniu Chrome"
+ },
+ "fetchingLatest": {
+ "message": "Pobieranie najnowszego Bento…"
+ },
+ "created": {
+ "message": "Utworzono $1"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 można odczytać, ale jeszcze nie otworzyć — Chrome nie mówi rozszerzeniu, gdzie folder znajduje się na dysku. <b>Przeglądaj wszystkie</b> znajdzie je jednym kliknięciem."
+ },
+ "andMore": {
+ "message": " i jeszcze $1"
+ },
+ "agoJustNow": {
+ "message": "przed chwilą"
+ },
+ "agoMinutes": {
+ "message": "$1 min temu"
+ },
+ "agoHour": {
+ "message": "$1 godz. temu"
+ },
+ "agoHours": {
+ "message": "$1 godz. temu"
+ },
+ "agoDay": {
+ "message": "$1 dzień temu"
+ },
+ "agoDays": {
+ "message": "$1 dni temu"
+ },
+ "searchScope": {
+ "message": "Wyszukiwanie obejmuje tytuły, nazwy plików, foldery i słowa wewnątrz dokumentów."
+ },
+ "folderEmpty": {
+ "message": "W tym folderze nic jeszcze nie ma"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Nowy dokument</b> umieści tu nowy."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray nie wie jeszcze, gdzie na dysku jest $1. Użyj „Znajdź moje foldery” albo otwórz raz z Findera dowolny dokument z tego folderu."
+ },
+ "cardRenamedTip": {
+ "message": "$1 to dokument Bento pod inną nazwą. Otworzy się stąd, ale zapis zapyta o miejsce docelowe — zapis w miejscu rozpoznaje tylko pliki kończące się na .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Nazwany .html zamiast .bento.html — otworzy się stąd, ale zapis zapyta o miejsce docelowe."
+ },
+ "menuOpen": {
+ "message": "Otwórz"
+ },
+ "menuDuplicate": {
+ "message": "Duplikuj"
+ },
+ "menuRename": {
+ "message": "Zmień nazwę…"
+ },
+ "menuCopyPath": {
+ "message": "Kopiuj ścieżkę"
+ },
+ "duplicatedAs": {
+ "message": "Zduplikowano jako $1"
+ },
+ "renamePrompt": {
+ "message": "Zmień nazwę dokumentu"
+ },
+ "renamedTo": {
+ "message": "Zmieniono nazwę na $1"
+ },
+ "pathCopied": {
+ "message": "Skopiowano ścieżkę"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — jeszcze nieotwarty"
+ },
+ "setupTitle": {
+ "message": "Dwie rzeczy i gotowe"
+ },
+ "setupLead": {
+ "message": "Potem ⌘S w dokumencie otwartym podwójnym kliknięciem zapisuje prosto do pliku — nigdy więcej pytania o miejsce docelowe."
+ },
+ "chooseFolder": {
+ "message": "Wybierz folder…"
+ },
+ "setupStep1": {
+ "message": "Wybierz folder, w którym trzymasz dokumenty"
+ },
+ "setupStep1Note": {
+ "message": "Zwykle wystarczy jeden szeroki folder — obejmuje wszystko, co jest w środku."
+ },
+ "setupStep2": {
+ "message": "Włącz dostęp do plików lokalnych"
+ },
+ "setupStep2Note": {
+ "message": "W <code>chrome://extensions</code> → Bento Tray → <b>Zezwalaj na dostęp do adresów URL plików</b>. Chrome nie pozwala rozszerzeniu włączyć tego samodzielnie."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Aktualizacja, a foldery miały tu być?</b> Rozpakowane rozszerzenie jest identyfikowane po ścieżce folderu, więc nowa kopia wczytana z innego folderu to inne rozszerzenie. Twoje foldery nadal należą do starego. Zamiast tego podmień pliki w pierwotnym folderze i naciśnij <b>Załaduj ponownie</b> w <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Dostęp do plików lokalnych jest wyłączony</b> — nic nie zapisze się w miejscu, dopóki go nie włączysz. Włącz <b>Zezwalaj na dostęp do adresów URL plików</b> w <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 folder wymaga ponownego połączenia.</b> Połącz go ponownie w <b>Ustawieniach</b> i wybierz <b>Zezwalaj przy każdej wizycie</b> — jedyną opcję, która się utrzymuje."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> można wyświetlić na liście, ale jeszcze nie otworzyć — Chrome nigdy nie mówi rozszerzeniu, gdzie folder znajduje się na dysku."
+ },
+ "findFolders": {
+ "message": "Znajdź moje foldery"
+ },
+ "looking": {
+ "message": "Szukanie…"
+ },
+ "findDeclined": {
+ "message": "<b>Nic nie szkodzi.</b> Zamiast tego otwórz raz z Findera dowolny dokument w $1 — ta strona to zauważy."
+ },
+ "foundFolder": {
+ "message": "Znaleziono $1 folder"
+ },
+ "foundFolders": {
+ "message": "Znaleziono $1 foldery"
+ },
+ "foundNothing": {
+ "message": "W historii nic jeszcze nie ma — otwórz jeden dokument z Findera"
+ },
+ "setFoldersSub": {
+ "message": "Dokumenty w tych folderach zapisują się prosto do pliku, bez pytania o miejsce. Folder obejmuje wszystko, co jest w środku."
+ },
+ "noneYet": {
+ "message": "Jeszcze żadnego."
+ },
+ "savesInPlace": {
+ "message": "zapis w miejscu"
+ },
+ "needsReconnecting": {
+ "message": "wymaga ponownego połączenia"
+ },
+ "reconnectTip": {
+ "message": "Chrome zapyta o przywrócenie tego folderu. „Nie zezwalaj” go porzuca, a potem Chrome czeka co najmniej do ponownego uruchomienia, zanim zapyta znowu."
+ },
+ "remove": {
+ "message": "Usuń"
+ },
+ "removeTip": {
+ "message": "Odbiera dostęp. Chrome może nadal pamiętać uprawnienie, więc ponowne dodanie folderu może nie wywołać pytania."
+ },
+ "setAccessTitle": {
+ "message": "Dostęp do plików lokalnych"
+ },
+ "setAccessSub": {
+ "message": "Chrome nie pozwala rozszerzeniu włączyć tego samodzielnie, a bez tego nic nie działa."
+ },
+ "stateOn": {
+ "message": "Włączony"
+ },
+ "stateOff": {
+ "message": "Wyłączony"
+ },
+ "stateUnknown": {
+ "message": "Nieznany"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray może czytać strony otwarte z dysku."
+ },
+ "accessOffNote": {
+ "message": "Otwórz chrome://extensions, znajdź Bento Tray i włącz „Zezwalaj na dostęp do adresów URL plików”."
+ },
+ "accessUnknownNote": {
+ "message": "Ta przeglądarka tego nie zgłasza. Jeśli zapis nadal pyta, sprawdź to w chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Wersja"
+ },
+ "setVersionUnpacked": {
+ "message": "Ta kopia została wczytana jako rozpakowana, więc Chrome nigdy jej nie zaktualizuje."
+ },
+ "setVersionStore": {
+ "message": "Zainstalowana ze sklepu, więc aktualizuje się sama."
+ },
+ "versionAvailable": {
+ "message": "Dostępna jest wersja $1"
+ },
+ "versionUpToDate": {
+ "message": "aktualna według ostatniego sprawdzenia"
+ },
+ "versionManaged": {
+ "message": "utrzymywana w aktualności przez przeglądarkę"
+ },
+ "getIt": {
+ "message": "Pobierz"
+ },
+ "checkNow": {
+ "message": "Sprawdź teraz"
+ },
+ "autoCheckPref": {
+ "message": "<b>Sprawdzaj nową wersję przy uruchomieniu przeglądarki.</b><br>Jedno żądanie do bento.page o plik statyczny. Nie wysyła identyfikatorów, numeru wersji ani niczego o Twoich dokumentach — porównanie odbywa się tutaj. Wyłącz, a nic nigdy nie zostanie pobrane; <b>Sprawdź teraz</b> nadal działa."
+ },
+ "expectedSha": {
+ "message": "Oczekiwana suma SHA-256 pliku zip: $1"
+ },
+ "setReachTitle": {
+ "message": "Do czego to sięga"
+ },
+ "setReachSub": {
+ "message": "Tylko do folderów powyżej i tylko do pliku, z którego strona faktycznie została otwarta. Nic nie jest wysyłane i nic nie jest czytane gdzie indziej."
+ },
+ "updateAvailable": {
+ "message": "<b>Dostępna jest wersja Bento Tray $1.</b> Ta kopia została wczytana jako rozpakowana, więc Chrome nigdy jej nie zaktualizuje."
+ },
+ "updateStep1": {
+ "message": "Pobierz ją z GitHuba"
+ },
+ "updateStep2": {
+ "message": "Podmień pliki <b>w folderze, z którego ją wczytałeś</b> — w tym samym, inaczej Chrome uzna to za inne rozszerzenie i przyznane foldery nie przejdą razem z nim"
+ },
+ "updateStep3": {
+ "message": "Otwórz <code>chrome://extensions</code> i naciśnij <b>Załaduj ponownie</b> przy Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Pobieranie $1…"
+ },
+ "createdIn": {
+ "message": "Utworzono $1 ($2) w $3"
+ },
+ "intoFolder": {
+ "message": "do $1"
+ },
+ "helpWhatTitle": {
+ "message": "Co robi Bento Tray"
+ },
+ "helpWhatSub": {
+ "message": "Dokument Bento to jeden plik HTML, który niesie własny edytor. Otwarty prosto z dysku nie może zapisać sam do siebie — więc zapis za każdym razem pyta o miejsce docelowe. Bento Tray usuwa to pytanie."
+ },
+ "tourSaveTitle": {
+ "message": "Zapis w miejscu"
+ },
+ "tourSaveBody": {
+ "message": "⌘S zapisuje prosto do otwartego pliku, bez okna dialogowego. Autozapis i aktualizacje w miejscu idą tą samą drogą."
+ },
+ "tourFindTitle": {
+ "message": "Znajdź swoje dokumenty"
+ },
+ "tourFindBody": {
+ "message": "Każdy dokument Bento w Twoich folderach, z prawdziwym tytułem i obrazkiem pierwszej strony. Wyszukiwanie obejmuje też to, co jest w nich napisane."
+ },
+ "tourSwitchTitle": {
+ "message": "Przełączaj w trakcie pracy"
+ },
+ "tourSwitchBody": {
+ "message": "Naciśnij <kbd>Alt</kbd>+<kbd>B</kbd> albo kliknij prawym przyciskiem w dokumencie, aby otworzyć panel obok."
+ },
+ "tourNewTitle": {
+ "message": "Utwórz nowy"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Nowy dokument</b> pobiera bieżące wydanie Slides, Spaces lub Dash i umieszcza nowy dokument w Twoim folderze."
+ },
+ "helpNeedsTitle": {
+ "message": "Czego potrzebuje od Ciebie"
+ },
+ "helpNeedsSub": {
+ "message": "Dwóch rzeczy, których to rozszerzenie samo nie może załatwić."
+ },
+ "helpFolder": {
+ "message": "Folder"
+ },
+ "helpFolderGranted": {
+ "message": "przyznano: $1 — dokumenty w nich zapisują się w miejscu"
+ },
+ "helpFolderNone": {
+ "message": "Jeszcze nie wybrano. Jeden szeroki folder obejmuje wszystko, co jest w środku."
+ },
+ "helpAccessOff": {
+ "message": "Wyłączony. Włącz <b>Zezwalaj na dostęp do adresów URL plików</b> w <code>chrome://extensions</code> — żadne rozszerzenie nie może włączyć tego samo."
+ },
+ "helpAccessUnknown": {
+ "message": "Ta przeglądarka tego nie zgłasza. Jeśli zapis nadal pyta, sprawdź to w <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Włączony — Bento Tray może czytać strony otwarte z dysku."
+ },
+ "helpNeverTitle": {
+ "message": "Czego nigdy nie robi"
+ },
+ "helpNeverSub": {
+ "message": "Czyta i zapisuje tylko wewnątrz powyższych folderów i tylko plik, z którego strona faktycznie została otwarta — przeglądarka mówi który, więc dokument nie może wskazać cudzego pliku. Nic o Twoich dokumentach nie jest nigdzie wysyłane, a rozszerzenie nie ma serwera, na który mogłoby je wysłać."
+ },
+ "helpAboutTitle": {
+ "message": "Informacje"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · część projektu Bento · licencja MIT"
+ },
+ "linkSource": {
+ "message": "Źródła na GitHubie"
+ },
+ "linkIssues": {
+ "message": "Zgłoś problem"
+ },
+ "linkReleases": {
+ "message": "Wydania"
+ },
+ "primeMiddle": {
+ "message": "ta, która się utrzymuje"
+ },
+ "primeNote": {
+ "message": "Pozostałe dwie też działają, ale Chrome zapyta znowu — pierwsza przy każdym uruchomieniu, ostatnia po odczekaniu."
+ }
+}
diff --git a/tray/webext/_locales/pt_BR/messages.json b/tray/webext/_locales/pt_BR/messages.json
new file mode 100644
index 00000000..8d5a5b7a
--- /dev/null
+++ b/tray/webext/_locales/pt_BR/messages.json
@@ -0,0 +1,446 @@
+{
+ "appDesc": {
+ "message": "Salva um documento Bento no arquivo que você abriu, sem perguntar onde guardá-lo.",
+ "description": "Chrome Web Store listing description. 132 characters maximum — the store truncates."
+ },
+ "navAll": {
+ "message": "Todos os documentos"
+ },
+ "navFolders": {
+ "message": "Pastas"
+ },
+ "navHelp": {
+ "message": "Ajuda e sobre"
+ },
+ "navSettings": {
+ "message": "Configurações"
+ },
+ "addFolder": {
+ "message": "+ Adicionar uma pasta…"
+ },
+ "searchDocs": {
+ "message": "Buscar documentos"
+ },
+ "searchDocsSlash": {
+ "message": "Buscar documentos /"
+ },
+ "sortTitle": {
+ "message": "Ordenar"
+ },
+ "sortRecent": {
+ "message": "Alterados recentemente"
+ },
+ "sortName": {
+ "message": "Nome"
+ },
+ "sortFolder": {
+ "message": "Pasta"
+ },
+ "newDocument": {
+ "message": "+ Novo documento"
+ },
+ "browseAll": {
+ "message": "Ver todos"
+ },
+ "reconnectFolders": {
+ "message": "Reconectar pastas"
+ },
+ "primeIntro": {
+ "message": "O Chrome vai perguntar. Escolha a opção do meio:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — uma pasta precisa ser reconectada",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedTitle": {
+ "message": "O Bento Tray precisa ser reconectado",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedBody": {
+ "message": "O Chrome retirou a permissão de uma pasta. Até ser restaurada, salvar um documento vai perguntar onde colocá-lo.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnect": {
+ "message": "Reconectar"
+ },
+ "ctxOpenPanel": {
+ "message": "Abrir o painel do Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "Ainda não há documentos Bento nas suas pastas."
+ },
+ "noMatches": {
+ "message": "Nada corresponde a “$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Abra uma vez um documento em $1 pelo Finder e tudo dessa pasta poderá ser aberto daqui."
+ },
+ "encrypted": {
+ "message": "Protegido por senha"
+ },
+ "notSavedYet": {
+ "message": "Ainda não salvo"
+ },
+ "fileAccessOffShort": {
+ "message": "O acesso a arquivos locais está desligado",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noFoldersYet": {
+ "message": "Nenhuma pasta ainda"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 pasta precisa ser reconectada",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "statusOneFolder": {
+ "message": "$1 pasta · salva no lugar"
+ },
+ "statusFolders": {
+ "message": "$1 pastas · salva no lugar"
+ },
+ "renewNotOffered": {
+ "message": "O Chrome não ofereceu restaurá-la",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "renewTryAfterRestart": {
+ "message": "Tente de novo depois de reiniciar o Chrome",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "fetchingLatest": {
+ "message": "Baixando o Bento mais recente…"
+ },
+ "created": {
+ "message": "$1 criado"
+ },
+ "panelUnplaced": {
+ "message": "É possível ler <b>$1</b>$2, mas ainda não abrir — o Chrome não informa a uma extensão onde uma pasta fica no disco. <b>Ver todos</b> encontra tudo com um clique.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "andMore": {
+ "message": " e mais $1"
+ },
+ "agoJustNow": {
+ "message": "agora mesmo"
+ },
+ "agoMinutes": {
+ "message": "há $1 min"
+ },
+ "agoHour": {
+ "message": "há $1 hora"
+ },
+ "agoHours": {
+ "message": "há $1 horas"
+ },
+ "agoDay": {
+ "message": "há $1 dia"
+ },
+ "agoDays": {
+ "message": "há $1 dias"
+ },
+ "searchScope": {
+ "message": "A busca olha títulos, nomes de arquivo, pastas e o texto dentro dos documentos."
+ },
+ "folderEmpty": {
+ "message": "Ainda não há nada nesta pasta"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Novo documento</b> coloca um aqui."
+ },
+ "cardUnplacedTip": {
+ "message": "O Bento Tray ainda não sabe onde $1 está no disco. Use “Encontrar minhas pastas” ou abra uma vez um documento dela pelo Finder.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "cardRenamedTip": {
+ "message": "$1 é um documento Bento com outro nome. Abre daqui, mas ao salvar vai perguntar onde — salvar no lugar só reconhece arquivos terminados em .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Chama-se .html em vez de .bento.html — abre daqui, mas ao salvar vai perguntar onde."
+ },
+ "menuOpen": {
+ "message": "Abrir"
+ },
+ "menuDuplicate": {
+ "message": "Duplicar"
+ },
+ "menuRename": {
+ "message": "Renomear…"
+ },
+ "menuCopyPath": {
+ "message": "Copiar caminho"
+ },
+ "duplicatedAs": {
+ "message": "Duplicado como $1"
+ },
+ "renamePrompt": {
+ "message": "Renomear documento"
+ },
+ "renamedTo": {
+ "message": "Renomeado para $1"
+ },
+ "pathCopied": {
+ "message": "Caminho copiado"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — ainda não aberta"
+ },
+ "setupTitle": {
+ "message": "Duas coisas e está pronto"
+ },
+ "setupLead": {
+ "message": "Depois disso, ⌘S num documento aberto com duplo clique escreve direto no arquivo — sem nunca perguntar onde."
+ },
+ "chooseFolder": {
+ "message": "Escolher uma pasta…"
+ },
+ "setupStep1": {
+ "message": "Escolha a pasta onde seus documentos ficam"
+ },
+ "setupStep1Note": {
+ "message": "Uma pasta ampla costuma bastar — cobre tudo que está dentro."
+ },
+ "setupStep2": {
+ "message": "Ligue o acesso a arquivos locais",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupStep2Note": {
+ "message": "Em <code>chrome://extensions</code> → Bento Tray → <b>Permitir acesso a URLs de arquivo</b>. O Chrome não deixa uma extensão ligar isso sozinha.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Atualizou e esperava ver suas pastas?</b> Uma extensão descompactada é identificada pelo caminho da pasta, então carregar uma cópia nova de outra pasta faz dela outra extensão. Suas pastas continuam concedidas à antiga. Substitua os arquivos na pasta original e clique em <b>Atualizar</b> em <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>O acesso a arquivos locais está desligado</b> — até ligar, nada salva no lugar. Ative <b>Permitir acesso a URLs de arquivo</b> em <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 pasta precisa ser reconectada.</b> Reconecte em <b>Configurações</b> e escolha a opção do meio — a única que dura.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> pode ser listada mas ainda não aberta — o Chrome nunca diz a uma extensão onde uma pasta fica no disco.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "findFolders": {
+ "message": "Encontrar minhas pastas"
+ },
+ "looking": {
+ "message": "Procurando…"
+ },
+ "findDeclined": {
+ "message": "<b>Sem problema.</b> Abra uma vez um documento em $1 pelo Finder — esta página percebe."
+ },
+ "foundFolder": {
+ "message": "$1 pasta encontrada"
+ },
+ "foundFolders": {
+ "message": "$1 pastas encontradas"
+ },
+ "foundNothing": {
+ "message": "Nada no histórico ainda — abra um documento pelo Finder"
+ },
+ "setFoldersSub": {
+ "message": "Documentos nelas salvam direto de volta no arquivo, sem perguntar onde. Uma pasta cobre tudo que está dentro."
+ },
+ "noneYet": {
+ "message": "Nenhuma ainda."
+ },
+ "savesInPlace": {
+ "message": "salva no lugar"
+ },
+ "needsReconnecting": {
+ "message": "precisa ser reconectada",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnectTip": {
+ "message": "O Chrome vai pedir para restaurar esta pasta. Recusar remove a pasta, e depois o Chrome espera pelo menos um reinício antes de oferecer de novo.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "remove": {
+ "message": "Remover"
+ },
+ "removeTip": {
+ "message": "Retira o acesso. O Chrome pode continuar lembrando da permissão, então adicionar a pasta de novo talvez não pergunte outra vez.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessTitle": {
+ "message": "Acesso a arquivos locais",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessSub": {
+ "message": "O Chrome não deixa uma extensão ligar isso sozinha, e sem isso nada funciona.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "stateOn": {
+ "message": "Ligado"
+ },
+ "stateOff": {
+ "message": "Desligado"
+ },
+ "stateUnknown": {
+ "message": "Desconhecido"
+ },
+ "accessOnNote": {
+ "message": "O Bento Tray pode ler páginas que você abriu do disco.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessOffNote": {
+ "message": "Abra chrome://extensions, encontre o Bento Tray e ative “Permitir acesso a URLs de arquivo”.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessUnknownNote": {
+ "message": "Este navegador não informa. Se salvar ainda perguntar, verifique em chrome://extensions.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setVersionTitle": {
+ "message": "Versão"
+ },
+ "setVersionUnpacked": {
+ "message": "Esta cópia foi carregada descompactada, então o Chrome nunca vai atualizá-la."
+ },
+ "setVersionStore": {
+ "message": "Instalado pela loja, então se atualiza sozinho."
+ },
+ "versionAvailable": {
+ "message": "$1 está disponível"
+ },
+ "versionUpToDate": {
+ "message": "em dia na última verificação"
+ },
+ "versionManaged": {
+ "message": "mantido em dia pelo navegador"
+ },
+ "getIt": {
+ "message": "Obter"
+ },
+ "checkNow": {
+ "message": "Verificar agora"
+ },
+ "autoCheckPref": {
+ "message": "<b>Procurar uma nova versão quando o navegador iniciar.</b><br>Uma requisição ao bento.page por um arquivo estático. Não envia identificadores, nem o número da versão, nem nada sobre seus documentos — a comparação acontece aqui. Desligado, nada é requisitado; <b>Verificar agora</b> continua funcionando.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "expectedSha": {
+ "message": "SHA-256 esperado do zip: $1"
+ },
+ "setReachTitle": {
+ "message": "O que ela alcança",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setReachSub": {
+ "message": "Só as pastas acima, e só o arquivo de onde uma página foi aberta. Nada é enviado e nada é lido em outro lugar.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 está disponível.</b> Esta cópia foi carregada descompactada, então o Chrome nunca vai atualizá-la."
+ },
+ "updateStep1": {
+ "message": "Baixe do GitHub"
+ },
+ "updateStep2": {
+ "message": "Substitua os arquivos <b>na pasta de onde você carregou</b> — a mesma pasta, ou o Chrome trata como outra extensão e suas pastas concedidas não vêm junto",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateStep3": {
+ "message": "Abra <code>chrome://extensions</code> e clique em <b>Atualizar</b> no Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Baixando $1…"
+ },
+ "createdIn": {
+ "message": "$1 ($2) criado em $3"
+ },
+ "intoFolder": {
+ "message": "em $1"
+ },
+ "helpWhatTitle": {
+ "message": "O que o Bento Tray faz"
+ },
+ "helpWhatSub": {
+ "message": "Um documento Bento é um arquivo HTML que carrega o próprio editor. Aberto direto do disco, o navegador não deixa ele escrever em si mesmo — então salvar pergunta onde colocar, toda vez. O Bento Tray é o que tira essa pergunta."
+ },
+ "tourSaveTitle": {
+ "message": "Salvar no lugar"
+ },
+ "tourSaveBody": {
+ "message": "⌘S escreve direto no arquivo que você abriu, sem diálogo. O salvamento automático e as atualizações seguem o mesmo caminho."
+ },
+ "tourFindTitle": {
+ "message": "Encontre seus documentos"
+ },
+ "tourFindBody": {
+ "message": "Todo documento Bento nas suas pastas, com o título de verdade e uma imagem da primeira página. A busca cobre o que está escrito dentro deles."
+ },
+ "tourSwitchTitle": {
+ "message": "Troque enquanto trabalha"
+ },
+ "tourSwitchBody": {
+ "message": "Aperte <kbd>Alt</kbd>+<kbd>B</kbd>, ou clique com o botão direito dentro de um documento, para um painel ao lado."
+ },
+ "tourNewTitle": {
+ "message": "Crie um novo"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Novo documento</b> baixa a versão atual do Slides, Spaces ou Dash e coloca um documento novo na sua pasta."
+ },
+ "helpNeedsTitle": {
+ "message": "O que ela precisa de você"
+ },
+ "helpNeedsSub": {
+ "message": "Duas coisas, ambas fora do alcance desta extensão."
+ },
+ "helpFolder": {
+ "message": "Uma pasta"
+ },
+ "helpFolderGranted": {
+ "message": "$1 concedidas — documentos dentro delas salvam no lugar"
+ },
+ "helpFolderNone": {
+ "message": "Ainda não escolhida. Uma pasta ampla cobre tudo que está dentro."
+ },
+ "helpAccessOff": {
+ "message": "Desligado. Ative <b>Permitir acesso a URLs de arquivo</b> em <code>chrome://extensions</code> — nenhuma extensão consegue ligar isso sozinha.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessUnknown": {
+ "message": "Este navegador não informa. Se salvar ainda perguntar, verifique em <code>chrome://extensions</code>.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessOn": {
+ "message": "Ligado — o Bento Tray pode ler páginas que você abriu do disco.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverTitle": {
+ "message": "O que ela nunca faz",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverSub": {
+ "message": "Ela lê e escreve apenas dentro das pastas acima, e apenas o arquivo de onde uma página foi realmente aberta — o navegador diz qual é, então um documento não pode apontar o arquivo de outro. Nada dos seus documentos é enviado para lugar nenhum, e a extensão não tem servidor para isso.",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAboutTitle": {
+ "message": "Sobre"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · parte do projeto Bento · licença MIT"
+ },
+ "linkSource": {
+ "message": "Código no GitHub"
+ },
+ "linkIssues": {
+ "message": "Relatar um problema"
+ },
+ "linkReleases": {
+ "message": "Versões"
+ },
+ "primeMiddle": {
+ "message": "a que dura"
+ },
+ "primeNote": {
+ "message": "As outras duas também funcionam, mas o Chrome pergunta de novo — a primeira a cada reinício, a última depois de uma espera."
+ }
+}
diff --git a/tray/webext/_locales/ru/messages.json b/tray/webext/_locales/ru/messages.json
new file mode 100644
index 00000000..830792c0
--- /dev/null
+++ b/tray/webext/_locales/ru/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Сохраняйте документ Bento обратно в открытый файл, без вопроса о месте сохранения."
+ },
+ "navAll": {
+ "message": "Все документы"
+ },
+ "navFolders": {
+ "message": "Папки"
+ },
+ "navHelp": {
+ "message": "Справка и о программе"
+ },
+ "navSettings": {
+ "message": "Настройки"
+ },
+ "addFolder": {
+ "message": "+ Добавить папку…"
+ },
+ "searchDocs": {
+ "message": "Поиск по документам"
+ },
+ "searchDocsSlash": {
+ "message": "Поиск по документам /"
+ },
+ "sortTitle": {
+ "message": "Сортировка"
+ },
+ "sortRecent": {
+ "message": "Недавно изменённые"
+ },
+ "sortName": {
+ "message": "Имя"
+ },
+ "sortFolder": {
+ "message": "Папка"
+ },
+ "newDocument": {
+ "message": "+ Новый документ"
+ },
+ "browseAll": {
+ "message": "Показать все"
+ },
+ "reconnectFolders": {
+ "message": "Переподключить папки"
+ },
+ "primeIntro": {
+ "message": "Сейчас Chrome спросит. Выберите средний вариант:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — папку нужно переподключить"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray нужно переподключить"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome отозвал разрешение на папку. Пока оно не восстановлено, при каждом сохранении будет спрашиваться, куда положить файл."
+ },
+ "reconnect": {
+ "message": "Переподключить"
+ },
+ "ctxOpenPanel": {
+ "message": "Открыть панель Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "В ваших папках пока нет документов Bento."
+ },
+ "noMatches": {
+ "message": "Ничего не найдено по запросу «$1»"
+ },
+ "rowUnplacedTip": {
+ "message": "Откройте любой документ в $1 один раз из Finder — и всё в этой папке можно будет открывать отсюда."
+ },
+ "encrypted": {
+ "message": "Защищён паролем"
+ },
+ "notSavedYet": {
+ "message": "Ещё не сохранён"
+ },
+ "fileAccessOffShort": {
+ "message": "Доступ к локальным файлам выключен"
+ },
+ "noFoldersYet": {
+ "message": "Папок пока нет"
+ },
+ "foldersNeedReconnect": {
+ "message": "Папок нужно переподключить: $1"
+ },
+ "statusOneFolder": {
+ "message": "папок: $1 · сохраняет на месте"
+ },
+ "statusFolders": {
+ "message": "папок: $1 · сохраняют на месте"
+ },
+ "renewNotOffered": {
+ "message": "Chrome не предложил восстановить её"
+ },
+ "renewTryAfterRestart": {
+ "message": "Попробуйте снова после перезапуска Chrome"
+ },
+ "fetchingLatest": {
+ "message": "Загружается последняя версия Bento…"
+ },
+ "created": {
+ "message": "Создано: $1"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 можно прочитать, но пока нельзя открыть — Chrome не сообщает расширению, где папка находится на диске. <b>Показать все</b> найдёт их одним щелчком."
+ },
+ "andMore": {
+ "message": " и ещё $1"
+ },
+ "agoJustNow": {
+ "message": "только что"
+ },
+ "agoMinutes": {
+ "message": "$1 мин назад"
+ },
+ "agoHour": {
+ "message": "$1 ч назад"
+ },
+ "agoHours": {
+ "message": "$1 ч назад"
+ },
+ "agoDay": {
+ "message": "$1 дн. назад"
+ },
+ "agoDays": {
+ "message": "$1 дн. назад"
+ },
+ "searchScope": {
+ "message": "Поиск смотрит на заголовки, имена файлов, папки и слова внутри документов."
+ },
+ "folderEmpty": {
+ "message": "В этой папке пока пусто"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Новый документ</b> создаст здесь новый."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray пока не знает, где $1 находится на диске. Нажмите «Найти мои папки» или один раз откройте из Finder любой документ оттуда."
+ },
+ "cardRenamedTip": {
+ "message": "$1 — это документ Bento под другим именем. Он открывается отсюда, но при сохранении спросит место — сохранение на месте распознаёт только файлы с окончанием .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Назван .html, а не .bento.html — открывается отсюда, но при сохранении спросит место."
+ },
+ "menuOpen": {
+ "message": "Открыть"
+ },
+ "menuDuplicate": {
+ "message": "Дублировать"
+ },
+ "menuRename": {
+ "message": "Переименовать…"
+ },
+ "menuCopyPath": {
+ "message": "Копировать путь"
+ },
+ "duplicatedAs": {
+ "message": "Дублировано как $1"
+ },
+ "renamePrompt": {
+ "message": "Переименовать документ"
+ },
+ "renamedTo": {
+ "message": "Переименовано в $1"
+ },
+ "pathCopied": {
+ "message": "Путь скопирован"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — ещё не открывалась"
+ },
+ "setupTitle": {
+ "message": "Две вещи — и всё готово"
+ },
+ "setupLead": {
+ "message": "После этого ⌘S в документе, открытом двойным щелчком, пишет прямо в файл — вопроса о месте больше никогда не будет."
+ },
+ "chooseFolder": {
+ "message": "Выбрать папку…"
+ },
+ "setupStep1": {
+ "message": "Выберите папку, где лежат ваши документы"
+ },
+ "setupStep1Note": {
+ "message": "Обычно достаточно одной широкой папки — она охватывает всё внутри."
+ },
+ "setupStep2": {
+ "message": "Включите доступ к локальным файлам"
+ },
+ "setupStep2Note": {
+ "message": "В <code>chrome://extensions</code> → Bento Tray → <b>Разрешить открывать файлы по ссылкам</b>. Chrome не позволяет расширению включить это самому."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Обновились и ждали найти здесь свои папки?</b> Распакованное расширение опознаётся по пути к папке, поэтому новая копия, загруженная из другой папки, — это другое расширение. Ваши папки по-прежнему принадлежат старому. Вместо этого замените файлы в исходной папке и нажмите <b>Обновить</b> в <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Доступ к локальным файлам выключен</b> — пока он выключен, ничего не сохранится на месте. Включите <b>Разрешить открывать файлы по ссылкам</b> в <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>Папок нужно переподключить: $1.</b> Переподключите в <b>Настройках</b> и выберите <b>Разрешать при каждом посещении</b> — единственный вариант, который сохраняется."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> можно показать в списке, но пока нельзя открыть — Chrome никогда не сообщает расширению, где папка находится на диске."
+ },
+ "findFolders": {
+ "message": "Найти мои папки"
+ },
+ "looking": {
+ "message": "Идёт поиск…"
+ },
+ "findDeclined": {
+ "message": "<b>Ничего страшного.</b> Тогда один раз откройте из Finder любой документ в $1 — эта страница заметит."
+ },
+ "foundFolder": {
+ "message": "Найдена папка: $1"
+ },
+ "foundFolders": {
+ "message": "Найдено папок: $1"
+ },
+ "foundNothing": {
+ "message": "В истории пока пусто — откройте один документ из Finder"
+ },
+ "setFoldersSub": {
+ "message": "Документы отсюда сохраняются прямо в файл, без вопроса о месте. Папка охватывает всё внутри."
+ },
+ "noneYet": {
+ "message": "Пока нет."
+ },
+ "savesInPlace": {
+ "message": "сохраняет на месте"
+ },
+ "needsReconnecting": {
+ "message": "нужно переподключить"
+ },
+ "reconnectTip": {
+ "message": "Chrome спросит о восстановлении этой папки. «Не разрешать» сбрасывает её, и после этого Chrome ждёт как минимум перезапуска, прежде чем спросить снова."
+ },
+ "remove": {
+ "message": "Удалить"
+ },
+ "removeTip": {
+ "message": "Отбирает доступ. Chrome может помнить разрешение, поэтому при повторном добавлении папки вопрос может и не появиться."
+ },
+ "setAccessTitle": {
+ "message": "Доступ к локальным файлам"
+ },
+ "setAccessSub": {
+ "message": "Chrome не позволяет расширению включить это самому, а без этого ничего не работает."
+ },
+ "stateOn": {
+ "message": "Вкл."
+ },
+ "stateOff": {
+ "message": "Выкл."
+ },
+ "stateUnknown": {
+ "message": "Неизвестно"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray может читать страницы, открытые с диска."
+ },
+ "accessOffNote": {
+ "message": "Откройте chrome://extensions, найдите Bento Tray и включите «Разрешить открывать файлы по ссылкам»."
+ },
+ "accessUnknownNote": {
+ "message": "Этот браузер не сообщает состояние. Если сохранение всё ещё спрашивает, проверьте в chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Версия"
+ },
+ "setVersionUnpacked": {
+ "message": "Эта копия загружена распакованной, поэтому Chrome никогда её не обновит."
+ },
+ "setVersionStore": {
+ "message": "Установлено из магазина, поэтому обновляется само."
+ },
+ "versionAvailable": {
+ "message": "Доступна версия $1"
+ },
+ "versionUpToDate": {
+ "message": "актуально на момент последней проверки"
+ },
+ "versionManaged": {
+ "message": "поддерживается в актуальном состоянии браузером"
+ },
+ "getIt": {
+ "message": "Получить"
+ },
+ "checkNow": {
+ "message": "Проверить сейчас"
+ },
+ "autoCheckPref": {
+ "message": "<b>Проверять новую версию при запуске браузера.</b><br>Один запрос к bento.page за статическим файлом. Он не отправляет идентификаторов, номера версии и ничего о ваших документах — сравнение происходит здесь. Выключите — и запросов не будет вовсе; <b>Проверить сейчас</b> продолжит работать."
+ },
+ "expectedSha": {
+ "message": "Ожидаемый SHA-256 архива: $1"
+ },
+ "setReachTitle": {
+ "message": "К чему есть доступ"
+ },
+ "setReachSub": {
+ "message": "Только к папкам выше и только к тому файлу, из которого действительно открыта страница. Ничего не выгружается и нигде больше ничего не читается."
+ },
+ "updateAvailable": {
+ "message": "<b>Доступна Bento Tray $1.</b> Эта копия загружена распакованной, поэтому Chrome никогда её не обновит."
+ },
+ "updateStep1": {
+ "message": "Скачайте с GitHub"
+ },
+ "updateStep2": {
+ "message": "Замените файлы <b>в той папке, из которой загружали</b> — именно в той же, иначе Chrome сочтёт это другим расширением и выданные папки за ним не последуют"
+ },
+ "updateStep3": {
+ "message": "Откройте <code>chrome://extensions</code> и нажмите <b>Обновить</b> у Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Загружается $1…"
+ },
+ "createdIn": {
+ "message": "Создано $1 ($2) в $3"
+ },
+ "intoFolder": {
+ "message": "в $1"
+ },
+ "helpWhatTitle": {
+ "message": "Что делает Bento Tray"
+ },
+ "helpWhatSub": {
+ "message": "Документ Bento — это один HTML-файл, несущий собственный редактор. Открытый прямо с диска, он не может записать сам в себя — поэтому сохранение каждый раз спрашивает, куда положить файл. Bento Tray убирает этот вопрос."
+ },
+ "tourSaveTitle": {
+ "message": "Сохранение на месте"
+ },
+ "tourSaveBody": {
+ "message": "⌘S пишет прямо в открытый файл, без диалога. Автосохранение и обновления на месте идут тем же путём."
+ },
+ "tourFindTitle": {
+ "message": "Найдите свои документы"
+ },
+ "tourFindBody": {
+ "message": "Каждый документ Bento в ваших папках, с настоящим заголовком и изображением первой страницы. Поиск охватывает и то, что написано внутри."
+ },
+ "tourSwitchTitle": {
+ "message": "Переключайтесь по ходу работы"
+ },
+ "tourSwitchBody": {
+ "message": "Нажмите <kbd>Alt</kbd>+<kbd>B</kbd> или щёлкните правой кнопкой внутри документа — панель откроется рядом."
+ },
+ "tourNewTitle": {
+ "message": "Создайте новый"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Новый документ</b> загружает текущий выпуск Slides, Spaces или Dash и кладёт новый документ в вашу папку."
+ },
+ "helpNeedsTitle": {
+ "message": "Что ему нужно от вас"
+ },
+ "helpNeedsSub": {
+ "message": "Две вещи, ни одну из которых это расширение не может устроить само."
+ },
+ "helpFolder": {
+ "message": "Папка"
+ },
+ "helpFolderGranted": {
+ "message": "разрешено: $1 — документы внутри сохраняются на месте"
+ },
+ "helpFolderNone": {
+ "message": "Ещё не выбрана. Одна широкая папка охватывает всё внутри."
+ },
+ "helpAccessOff": {
+ "message": "Выкл. Включите <b>Разрешить открывать файлы по ссылкам</b> в <code>chrome://extensions</code> — ни одно расширение не может включить это само."
+ },
+ "helpAccessUnknown": {
+ "message": "Этот браузер не сообщает состояние. Если сохранение всё ещё спрашивает, проверьте в <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Вкл. — Bento Tray может читать страницы, открытые с диска."
+ },
+ "helpNeverTitle": {
+ "message": "Чего оно никогда не делает"
+ },
+ "helpNeverSub": {
+ "message": "Оно читает и пишет только внутри папок выше и только тот файл, из которого действительно открыта страница — какой именно, сообщает браузер, так что документ не может назвать чужой файл. Ничего о ваших документах никуда не выгружается, и у расширения нет сервера, куда их можно было бы выгрузить."
+ },
+ "helpAboutTitle": {
+ "message": "О программе"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · часть проекта Bento · лицензия MIT"
+ },
+ "linkSource": {
+ "message": "Исходники на GitHub"
+ },
+ "linkIssues": {
+ "message": "Сообщить о проблеме"
+ },
+ "linkReleases": {
+ "message": "Выпуски"
+ },
+ "primeMiddle": {
+ "message": "тот, который сохраняется"
+ },
+ "primeNote": {
+ "message": "Два других тоже работают, но Chrome спросит снова — первый при каждом перезапуске, последний после ожидания."
+ }
+}
diff --git a/tray/webext/_locales/sv/messages.json b/tray/webext/_locales/sv/messages.json
new file mode 100644
index 00000000..a1f86ac9
--- /dev/null
+++ b/tray/webext/_locales/sv/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Spara ett Bento-dokument tillbaka till filen du öppnade, utan att bli tillfrågad om var."
+ },
+ "navAll": {
+ "message": "Alla dokument"
+ },
+ "navFolders": {
+ "message": "Mappar"
+ },
+ "navHelp": {
+ "message": "Hjälp och om"
+ },
+ "navSettings": {
+ "message": "Inställningar"
+ },
+ "addFolder": {
+ "message": "+ Lägg till en mapp…"
+ },
+ "searchDocs": {
+ "message": "Sök bland dokument"
+ },
+ "searchDocsSlash": {
+ "message": "Sök bland dokument /"
+ },
+ "sortTitle": {
+ "message": "Sortera"
+ },
+ "sortRecent": {
+ "message": "Senast ändrad"
+ },
+ "sortName": {
+ "message": "Namn"
+ },
+ "sortFolder": {
+ "message": "Mapp"
+ },
+ "newDocument": {
+ "message": "+ Nytt dokument"
+ },
+ "browseAll": {
+ "message": "Visa alla"
+ },
+ "reconnectFolders": {
+ "message": "Återanslut mappar"
+ },
+ "primeIntro": {
+ "message": "Chrome frågar strax. Välj mittenalternativet:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — en mapp behöver återanslutas"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray behöver återanslutas"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome har tagit bort behörigheten till en mapp. Tills den återställs frågar varje sparning var filen ska ligga."
+ },
+ "reconnect": {
+ "message": "Återanslut"
+ },
+ "ctxOpenPanel": {
+ "message": "Öppna Bento Tray-panelen"
+ },
+ "panelEmpty": {
+ "message": "Inga Bento-dokument i dina mappar ännu."
+ },
+ "noMatches": {
+ "message": "Inget matchar ”$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Öppna ett dokument i $1 en gång från Finder, så går allt i den mappen att öppna härifrån."
+ },
+ "encrypted": {
+ "message": "Lösenordsskyddad"
+ },
+ "notSavedYet": {
+ "message": "Inte sparad än"
+ },
+ "fileAccessOffShort": {
+ "message": "Åtkomst till lokala filer är av"
+ },
+ "noFoldersYet": {
+ "message": "Inga mappar än"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 mapp behöver återanslutas"
+ },
+ "statusOneFolder": {
+ "message": "$1 mapp · sparar på plats"
+ },
+ "statusFolders": {
+ "message": "$1 mappar · sparar på plats"
+ },
+ "renewNotOffered": {
+ "message": "Chrome erbjöd sig inte att återställa den"
+ },
+ "renewTryAfterRestart": {
+ "message": "Försök igen efter att ha startat om Chrome"
+ },
+ "fetchingLatest": {
+ "message": "Hämtar senaste Bento…"
+ },
+ "created": {
+ "message": "$1 skapad"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 går att läsa men inte att öppna än — Chrome berättar inte för ett tillägg var en mapp ligger på disken. <b>Visa alla</b> hittar dem med ett klick."
+ },
+ "andMore": {
+ "message": " och $1 till"
+ },
+ "agoJustNow": {
+ "message": "nyss"
+ },
+ "agoMinutes": {
+ "message": "för $1 min sedan"
+ },
+ "agoHour": {
+ "message": "för $1 timme sedan"
+ },
+ "agoHours": {
+ "message": "för $1 timmar sedan"
+ },
+ "agoDay": {
+ "message": "för $1 dag sedan"
+ },
+ "agoDays": {
+ "message": "för $1 dagar sedan"
+ },
+ "searchScope": {
+ "message": "Sökningen tittar på titlar, filnamn, mappar och orden inuti dokumenten."
+ },
+ "folderEmpty": {
+ "message": "Inget i den här mappen än"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Nytt dokument</b> lägger ett färskt här."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray vet inte var $1 ligger på disken än. Använd ”Hitta mina mappar”, eller öppna ett dokument därifrån i Finder en gång."
+ },
+ "cardRenamedTip": {
+ "message": "$1 är ett Bento-dokument under ett annat namn. Det öppnas härifrån, men sparning frågar efter en plats — sparning på plats känner bara igen filer som slutar på .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Heter .html i stället för .bento.html — det öppnas härifrån, men sparning frågar efter en plats."
+ },
+ "menuOpen": {
+ "message": "Öppna"
+ },
+ "menuDuplicate": {
+ "message": "Duplicera"
+ },
+ "menuRename": {
+ "message": "Byt namn…"
+ },
+ "menuCopyPath": {
+ "message": "Kopiera sökväg"
+ },
+ "duplicatedAs": {
+ "message": "Duplicerad som $1"
+ },
+ "renamePrompt": {
+ "message": "Byt namn på dokument"
+ },
+ "renamedTo": {
+ "message": "Fick namnet $1"
+ },
+ "pathCopied": {
+ "message": "Sökväg kopierad"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — inte öppnad än"
+ },
+ "setupTitle": {
+ "message": "Två saker, sedan är du klar"
+ },
+ "setupLead": {
+ "message": "Därefter skriver ⌘S i ett dokument du öppnat med dubbelklick direkt tillbaka till filen — aldrig mer någon fråga om var."
+ },
+ "chooseFolder": {
+ "message": "Välj en mapp…"
+ },
+ "setupStep1": {
+ "message": "Välj mappen där dina dokument ligger"
+ },
+ "setupStep1Note": {
+ "message": "En bred mapp räcker oftast — den täcker allt som finns i den."
+ },
+ "setupStep2": {
+ "message": "Slå på åtkomst till lokala filer"
+ },
+ "setupStep2Note": {
+ "message": "I <code>chrome://extensions</code> → Bento Tray → <b>Tillåt åtkomst till fil-URL:er</b>. Chrome låter inte ett tillägg slå på detta själv."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Uppgraderat och väntade dig dina mappar här?</b> Ett uppackat tillägg identifieras av sin mappsökväg, så en ny kopia som läses in från en annan mapp blir ett annat tillägg. Dina mappar hör fortfarande till det gamla. Byt i stället ut filerna i den ursprungliga mappen och tryck <b>Läs in igen</b> i <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Åtkomst till lokala filer är av</b> — inget sparas på plats förrän den är på. Slå på <b>Tillåt åtkomst till fil-URL:er</b> i <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 mapp behöver återanslutas.</b> Återanslut den under <b>Inställningar</b> och välj <b>Tillåt vid varje besök</b> — det enda alternativet som består."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> kan listas men inte öppnas än — Chrome berättar aldrig för ett tillägg var en mapp ligger på disken."
+ },
+ "findFolders": {
+ "message": "Hitta mina mappar"
+ },
+ "looking": {
+ "message": "Letar…"
+ },
+ "findDeclined": {
+ "message": "<b>Ingen fara.</b> Öppna i stället ett dokument i $1 från Finder en gång — den här sidan märker det."
+ },
+ "foundFolder": {
+ "message": "Hittade $1 mapp"
+ },
+ "foundFolders": {
+ "message": "Hittade $1 mappar"
+ },
+ "foundNothing": {
+ "message": "Inget i historiken än — öppna ett dokument från Finder"
+ },
+ "setFoldersSub": {
+ "message": "Dokument i dessa sparas direkt tillbaka till filen, utan fråga om var. En mapp täcker allt som finns i den."
+ },
+ "noneYet": {
+ "message": "Inga än."
+ },
+ "savesInPlace": {
+ "message": "sparar på plats"
+ },
+ "needsReconnecting": {
+ "message": "behöver återanslutas"
+ },
+ "reconnectTip": {
+ "message": "Chrome frågar om den här mappen får återställas. ”Tillåt inte” släpper den, och sedan väntar Chrome minst en omstart innan det frågar igen."
+ },
+ "remove": {
+ "message": "Ta bort"
+ },
+ "removeTip": {
+ "message": "Tar bort åtkomsten. Chrome kan ändå minnas behörigheten, så att lägga till mappen igen kanske inte frågar."
+ },
+ "setAccessTitle": {
+ "message": "Åtkomst till lokala filer"
+ },
+ "setAccessSub": {
+ "message": "Chrome låter inte ett tillägg slå på detta själv, och inget fungerar utan det."
+ },
+ "stateOn": {
+ "message": "På"
+ },
+ "stateOff": {
+ "message": "Av"
+ },
+ "stateUnknown": {
+ "message": "Okänt"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray kan läsa sidor du öppnat från disken."
+ },
+ "accessOffNote": {
+ "message": "Öppna chrome://extensions, hitta Bento Tray och slå på ”Tillåt åtkomst till fil-URL:er”."
+ },
+ "accessUnknownNote": {
+ "message": "Den här webbläsaren rapporterar det inte. Om sparning fortfarande frågar, kontrollera i chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Version"
+ },
+ "setVersionUnpacked": {
+ "message": "Den här kopian lästes in uppackad, så Chrome uppdaterar den aldrig."
+ },
+ "setVersionStore": {
+ "message": "Installerad från butiken, så den uppdaterar sig själv."
+ },
+ "versionAvailable": {
+ "message": "$1 finns tillgänglig"
+ },
+ "versionUpToDate": {
+ "message": "aktuell vid senaste kontrollen"
+ },
+ "versionManaged": {
+ "message": "hålls aktuell av webbläsaren"
+ },
+ "getIt": {
+ "message": "Hämta den"
+ },
+ "checkNow": {
+ "message": "Kontrollera nu"
+ },
+ "autoCheckPref": {
+ "message": "<b>Leta efter en ny version när webbläsaren startar.</b><br>En förfrågan till bento.page om en statisk fil. Den skickar inga identifierare, inget versionsnummer och inget om dina dokument — jämförelsen sker här. Stäng av den och inget efterfrågas någonsin; <b>Kontrollera nu</b> fungerar ändå."
+ },
+ "expectedSha": {
+ "message": "Förväntad SHA-256 för zip-filen: $1"
+ },
+ "setReachTitle": {
+ "message": "Vad detta når"
+ },
+ "setReachSub": {
+ "message": "Endast mapparna ovan, och endast filen som en sida faktiskt öppnades från. Inget laddas upp och inget läses någon annanstans."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 finns tillgänglig.</b> Den här kopian lästes in uppackad, så Chrome uppdaterar den aldrig."
+ },
+ "updateStep1": {
+ "message": "Hämta den från GitHub"
+ },
+ "updateStep2": {
+ "message": "Byt ut filerna <b>i mappen du läste in den från</b> — samma mapp, annars behandlar Chrome den som ett annat tillägg och dina beviljade mappar följer inte med"
+ },
+ "updateStep3": {
+ "message": "Öppna <code>chrome://extensions</code> och tryck <b>Läs in igen</b> på Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Hämtar $1…"
+ },
+ "createdIn": {
+ "message": "Skapade $1 ($2) i $3"
+ },
+ "intoFolder": {
+ "message": "i $1"
+ },
+ "helpWhatTitle": {
+ "message": "Vad Bento Tray gör"
+ },
+ "helpWhatSub": {
+ "message": "Ett Bento-dokument är en enda HTML-fil som bär sin egen redigerare. Öppnad direkt från disken låter en webbläsare den inte skriva tillbaka till sig själv — så varje sparning frågar var filen ska ligga. Bento Tray tar bort den frågan."
+ },
+ "tourSaveTitle": {
+ "message": "Spara på plats"
+ },
+ "tourSaveBody": {
+ "message": "⌘S skriver direkt tillbaka till filen du öppnade, utan dialogruta. Autosparning och uppdateringar på plats går samma väg."
+ },
+ "tourFindTitle": {
+ "message": "Hitta dina dokument"
+ },
+ "tourFindBody": {
+ "message": "Alla Bento-dokument i dina mappar, med sin riktiga titel och en bild av första sidan. Sökningen täcker även det som står inuti dem."
+ },
+ "tourSwitchTitle": {
+ "message": "Växla medan du arbetar"
+ },
+ "tourSwitchBody": {
+ "message": "Tryck <kbd>Alt</kbd>+<kbd>B</kbd>, eller högerklicka inuti ett dokument, för en panel bredvid."
+ },
+ "tourNewTitle": {
+ "message": "Skapa ett nytt"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Nytt dokument</b> hämtar den aktuella utgåvan av Slides, Spaces eller Dash och lägger ett färskt dokument i din mapp."
+ },
+ "helpNeedsTitle": {
+ "message": "Vad den behöver av dig"
+ },
+ "helpNeedsSub": {
+ "message": "Två saker, båda utanför det här tilläggets makt att ordna."
+ },
+ "helpFolder": {
+ "message": "En mapp"
+ },
+ "helpFolderGranted": {
+ "message": "$1 beviljade — dokument i dem sparas på plats"
+ },
+ "helpFolderNone": {
+ "message": "Inte vald än. En bred mapp täcker allt som finns i den."
+ },
+ "helpAccessOff": {
+ "message": "Av. Slå på <b>Tillåt åtkomst till fil-URL:er</b> i <code>chrome://extensions</code> — inget tillägg kan slå på detta själv."
+ },
+ "helpAccessUnknown": {
+ "message": "Den här webbläsaren rapporterar det inte. Om sparning fortfarande frågar, kontrollera i <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "På — Bento Tray kan läsa sidor du öppnat från disken."
+ },
+ "helpNeverTitle": {
+ "message": "Vad den aldrig gör"
+ },
+ "helpNeverSub": {
+ "message": "Den läser och skriver bara inuti mapparna ovan, och bara filen som en sida faktiskt öppnades från — webbläsaren talar om vilken, så ett dokument kan inte peka ut någon annans fil. Inget om dina dokument laddas upp någonstans, och tillägget har ingen server att ladda upp dem till."
+ },
+ "helpAboutTitle": {
+ "message": "Om"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · en del av Bento-projektet · MIT-licens"
+ },
+ "linkSource": {
+ "message": "Källkod på GitHub"
+ },
+ "linkIssues": {
+ "message": "Rapportera ett problem"
+ },
+ "linkReleases": {
+ "message": "Utgåvor"
+ },
+ "primeMiddle": {
+ "message": "det som består"
+ },
+ "primeNote": {
+ "message": "De andra två fungerar också, men Chrome frågar igen — vid varje omstart för det första, och efter en väntan för det sista."
+ }
+}
diff --git a/tray/webext/_locales/th/messages.json b/tray/webext/_locales/th/messages.json
new file mode 100644
index 00000000..b8449879
--- /dev/null
+++ b/tray/webext/_locales/th/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "บันทึกเอกสาร Bento กลับลงไฟล์ที่คุณเปิด โดยไม่ต้องถามปลายทาง"
+ },
+ "navAll": {
+ "message": "เอกสารทั้งหมด"
+ },
+ "navFolders": {
+ "message": "โฟลเดอร์"
+ },
+ "navHelp": {
+ "message": "วิธีใช้และเกี่ยวกับ"
+ },
+ "navSettings": {
+ "message": "การตั้งค่า"
+ },
+ "addFolder": {
+ "message": "+ เพิ่มโฟลเดอร์…"
+ },
+ "searchDocs": {
+ "message": "ค้นหาเอกสาร"
+ },
+ "searchDocsSlash": {
+ "message": "ค้นหาเอกสาร /"
+ },
+ "sortTitle": {
+ "message": "เรียงลำดับ"
+ },
+ "sortRecent": {
+ "message": "แก้ไขล่าสุด"
+ },
+ "sortName": {
+ "message": "ชื่อ"
+ },
+ "sortFolder": {
+ "message": "โฟลเดอร์"
+ },
+ "newDocument": {
+ "message": "+ เอกสารใหม่"
+ },
+ "browseAll": {
+ "message": "ดูทั้งหมด"
+ },
+ "reconnectFolders": {
+ "message": "เชื่อมต่อโฟลเดอร์อีกครั้ง"
+ },
+ "primeIntro": {
+ "message": "Chrome กำลังจะถาม เลือกตัวเลือกตรงกลาง:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — มีโฟลเดอร์ที่ต้องเชื่อมต่ออีกครั้ง"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray ต้องเชื่อมต่ออีกครั้ง"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome ยกเลิกสิทธิ์ของโฟลเดอร์หนึ่ง จนกว่าจะกู้คืน การบันทึกทุกครั้งจะถามว่าจะเก็บไฟล์ไว้ที่ใด"
+ },
+ "reconnect": {
+ "message": "เชื่อมต่ออีกครั้ง"
+ },
+ "ctxOpenPanel": {
+ "message": "เปิดแผง Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "ยังไม่มีเอกสาร Bento ในโฟลเดอร์ของคุณ"
+ },
+ "noMatches": {
+ "message": "ไม่พบสิ่งที่ตรงกับ “$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "เปิดเอกสารสักฉบับใน $1 จาก Finder สักครั้ง แล้วทุกอย่างในโฟลเดอร์นั้นจะเปิดได้จากที่นี่"
+ },
+ "encrypted": {
+ "message": "ป้องกันด้วยรหัสผ่าน"
+ },
+ "notSavedYet": {
+ "message": "ยังไม่ได้บันทึก"
+ },
+ "fileAccessOffShort": {
+ "message": "การเข้าถึงไฟล์ในเครื่องปิดอยู่"
+ },
+ "noFoldersYet": {
+ "message": "ยังไม่มีโฟลเดอร์"
+ },
+ "foldersNeedReconnect": {
+ "message": "มี $1 โฟลเดอร์ที่ต้องเชื่อมต่ออีกครั้ง"
+ },
+ "statusOneFolder": {
+ "message": "$1 โฟลเดอร์ · บันทึกทับที่เดิม"
+ },
+ "statusFolders": {
+ "message": "$1 โฟลเดอร์ · บันทึกทับที่เดิม"
+ },
+ "renewNotOffered": {
+ "message": "Chrome ไม่ได้เสนอให้กู้คืน"
+ },
+ "renewTryAfterRestart": {
+ "message": "ลองอีกครั้งหลังจากเริ่ม Chrome ใหม่"
+ },
+ "fetchingLatest": {
+ "message": "กำลังดึง Bento รุ่นล่าสุด…"
+ },
+ "created": {
+ "message": "สร้าง $1 แล้ว"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 อ่านได้แต่ยังเปิดไม่ได้ — Chrome ไม่บอกส่วนขยายว่าโฟลเดอร์อยู่ที่ใดบนดิสก์ <b>ดูทั้งหมด</b> หาเจอได้ในคลิกเดียว"
+ },
+ "andMore": {
+ "message": " และอีก $1 รายการ"
+ },
+ "agoJustNow": {
+ "message": "เมื่อครู่นี้"
+ },
+ "agoMinutes": {
+ "message": "$1 นาทีที่แล้ว"
+ },
+ "agoHour": {
+ "message": "$1 ชั่วโมงที่แล้ว"
+ },
+ "agoHours": {
+ "message": "$1 ชั่วโมงที่แล้ว"
+ },
+ "agoDay": {
+ "message": "$1 วันที่แล้ว"
+ },
+ "agoDays": {
+ "message": "$1 วันที่แล้ว"
+ },
+ "searchScope": {
+ "message": "การค้นหาดูทั้งชื่อเรื่อง ชื่อไฟล์ โฟลเดอร์ และคำที่อยู่ในเอกสาร"
+ },
+ "folderEmpty": {
+ "message": "ยังไม่มีอะไรในโฟลเดอร์นี้"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ เอกสารใหม่</b> จะวางเอกสารใหม่ไว้ที่นี่"
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray ยังไม่รู้ว่า $1 อยู่ที่ใดบนดิสก์ ใช้ “ค้นหาโฟลเดอร์ของฉัน” หรือเปิดเอกสารในนั้นจาก Finder สักครั้ง"
+ },
+ "cardRenamedTip": {
+ "message": "$1 เป็นเอกสาร Bento ที่ใช้ชื่ออื่น เปิดได้จากที่นี่ แต่การบันทึกจะถามปลายทาง — การบันทึกทับที่เดิมรู้จักเฉพาะไฟล์ที่ลงท้ายด้วย .bento.html"
+ },
+ "badgeRenamed": {
+ "message": "ตั้งชื่อเป็น .html แทน .bento.html — เปิดได้จากที่นี่ แต่การบันทึกจะถามปลายทาง"
+ },
+ "menuOpen": {
+ "message": "เปิด"
+ },
+ "menuDuplicate": {
+ "message": "ทำสำเนา"
+ },
+ "menuRename": {
+ "message": "เปลี่ยนชื่อ…"
+ },
+ "menuCopyPath": {
+ "message": "คัดลอกเส้นทาง"
+ },
+ "duplicatedAs": {
+ "message": "ทำสำเนาเป็น $1 แล้ว"
+ },
+ "renamePrompt": {
+ "message": "เปลี่ยนชื่อเอกสาร"
+ },
+ "renamedTo": {
+ "message": "เปลี่ยนชื่อเป็น $1 แล้ว"
+ },
+ "pathCopied": {
+ "message": "คัดลอกเส้นทางแล้ว"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — ยังไม่เคยเปิด"
+ },
+ "setupTitle": {
+ "message": "สองอย่าง แล้วก็พร้อมใช้"
+ },
+ "setupLead": {
+ "message": "หลังจากนี้ การกด ⌘S ในเอกสารที่คุณเปิดด้วยการดับเบิลคลิกจะเขียนกลับลงไฟล์โดยตรง — ไม่ถามปลายทางอีกเลย"
+ },
+ "chooseFolder": {
+ "message": "เลือกโฟลเดอร์…"
+ },
+ "setupStep1": {
+ "message": "เลือกโฟลเดอร์ที่เก็บเอกสารของคุณ"
+ },
+ "setupStep1Note": {
+ "message": "โฟลเดอร์กว้าง ๆ เพียงโฟลเดอร์เดียวมักพอ — ครอบคลุมทุกอย่างที่อยู่ข้างใน"
+ },
+ "setupStep2": {
+ "message": "เปิดการเข้าถึงไฟล์ในเครื่อง"
+ },
+ "setupStep2Note": {
+ "message": "ใน <code>chrome://extensions</code> → Bento Tray → <b>อนุญาตให้เข้าถึง URL ของไฟล์</b> Chrome ไม่ยอมให้ส่วนขยายเปิดสิ่งนี้ด้วยตัวเอง"
+ },
+ "setupUpgradeNote": {
+ "message": "<b>เพิ่งอัปเกรดแล้วคิดว่าโฟลเดอร์จะยังอยู่ที่นี่?</b> ส่วนขยายแบบไม่บีบอัดถูกระบุด้วยเส้นทางโฟลเดอร์ ดังนั้นสำเนาใหม่ที่โหลดจากโฟลเดอร์อื่นจึงเป็นส่วนขยายคนละตัว โฟลเดอร์ของคุณยังผูกอยู่กับตัวเดิม ให้แทนที่ไฟล์ในโฟลเดอร์เดิมแล้วกด <b>โหลดซ้ำ</b> ใน <code>chrome://extensions</code> แทน"
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>การเข้าถึงไฟล์ในเครื่องปิดอยู่</b> — จะไม่มีอะไรบันทึกทับที่เดิมจนกว่าจะเปิด เปิด <b>อนุญาตให้เข้าถึง URL ของไฟล์</b> ใน <code>chrome://extensions</code>"
+ },
+ "noticeLapsed": {
+ "message": "<b>มี $1 โฟลเดอร์ที่ต้องเชื่อมต่ออีกครั้ง</b> เชื่อมต่อใหม่ใน <b>การตั้งค่า</b> และเลือก <b>อนุญาตทุกครั้งที่เข้าชม</b> — ตัวเลือกเดียวที่คงอยู่"
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> แสดงในรายการได้แต่ยังเปิดไม่ได้ — Chrome ไม่เคยบอกส่วนขยายว่าโฟลเดอร์อยู่ที่ใดบนดิสก์"
+ },
+ "findFolders": {
+ "message": "ค้นหาโฟลเดอร์ของฉัน"
+ },
+ "looking": {
+ "message": "กำลังค้นหา…"
+ },
+ "findDeclined": {
+ "message": "<b>ไม่เป็นไร</b> ลองเปิดเอกสารสักฉบับใน $1 จาก Finder สักครั้งแทน — หน้านี้จะสังเกตเห็นเอง"
+ },
+ "foundFolder": {
+ "message": "พบ $1 โฟลเดอร์"
+ },
+ "foundFolders": {
+ "message": "พบ $1 โฟลเดอร์"
+ },
+ "foundNothing": {
+ "message": "ยังไม่มีอะไรในประวัติ — เปิดเอกสารสักฉบับจาก Finder"
+ },
+ "setFoldersSub": {
+ "message": "เอกสารในโฟลเดอร์เหล่านี้จะบันทึกกลับลงไฟล์โดยตรง ไม่ถามปลายทาง โฟลเดอร์หนึ่งครอบคลุมทุกอย่างที่อยู่ข้างใน"
+ },
+ "noneYet": {
+ "message": "ยังไม่มี"
+ },
+ "savesInPlace": {
+ "message": "บันทึกทับที่เดิม"
+ },
+ "needsReconnecting": {
+ "message": "ต้องเชื่อมต่ออีกครั้ง"
+ },
+ "reconnectTip": {
+ "message": "Chrome จะถามเพื่อกู้คืนโฟลเดอร์นี้ “ไม่อนุญาต” จะทิ้งมันไป และหลังจากนั้น Chrome จะรออย่างน้อยหนึ่งครั้งของการเริ่มใหม่ก่อนจะถามอีก"
+ },
+ "remove": {
+ "message": "นำออก"
+ },
+ "removeTip": {
+ "message": "ถอนสิทธิ์การเข้าถึง Chrome อาจยังจำสิทธิ์นั้นไว้ ดังนั้นการเพิ่มโฟลเดอร์กลับเข้ามาอาจไม่ถามอีก"
+ },
+ "setAccessTitle": {
+ "message": "การเข้าถึงไฟล์ในเครื่อง"
+ },
+ "setAccessSub": {
+ "message": "Chrome ไม่ยอมให้ส่วนขยายเปิดสิ่งนี้ด้วยตัวเอง และถ้าไม่มีมันก็ใช้งานอะไรไม่ได้เลย"
+ },
+ "stateOn": {
+ "message": "เปิด"
+ },
+ "stateOff": {
+ "message": "ปิด"
+ },
+ "stateUnknown": {
+ "message": "ไม่ทราบ"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray อ่านหน้าที่คุณเปิดจากดิสก์ได้"
+ },
+ "accessOffNote": {
+ "message": "เปิด chrome://extensions หา Bento Tray แล้วเปิด “อนุญาตให้เข้าถึง URL ของไฟล์”"
+ },
+ "accessUnknownNote": {
+ "message": "เบราว์เซอร์นี้ไม่รายงานสถานะ ถ้าการบันทึกยังถามอยู่ ให้ตรวจสอบใน chrome://extensions"
+ },
+ "setVersionTitle": {
+ "message": "เวอร์ชัน"
+ },
+ "setVersionUnpacked": {
+ "message": "สำเนานี้โหลดแบบไม่บีบอัด Chrome จึงไม่อัปเดตให้เลย"
+ },
+ "setVersionStore": {
+ "message": "ติดตั้งจากสโตร์ จึงอัปเดตตัวเอง"
+ },
+ "versionAvailable": {
+ "message": "มี $1 ให้ใช้แล้ว"
+ },
+ "versionUpToDate": {
+ "message": "เป็นรุ่นล่าสุด ณ การตรวจสอบครั้งก่อน"
+ },
+ "versionManaged": {
+ "message": "เบราว์เซอร์ดูแลให้เป็นรุ่นล่าสุด"
+ },
+ "getIt": {
+ "message": "ดาวน์โหลด"
+ },
+ "checkNow": {
+ "message": "ตรวจสอบเดี๋ยวนี้"
+ },
+ "autoCheckPref": {
+ "message": "<b>ตรวจหาเวอร์ชันใหม่เมื่อเบราว์เซอร์เริ่มทำงาน</b><br>คำขอหนึ่งครั้งไปยัง bento.page เพื่อขอไฟล์นิ่ง ๆ ไฟล์หนึ่ง ไม่ส่งตัวระบุตัวตน ไม่ส่งหมายเลขเวอร์ชัน และไม่ส่งอะไรเกี่ยวกับเอกสารของคุณ — การเปรียบเทียบเกิดขึ้นที่นี่ ปิดเสียก็จะไม่มีการร้องขอใด ๆ เลย ส่วน <b>ตรวจสอบเดี๋ยวนี้</b> ยังใช้ได้"
+ },
+ "expectedSha": {
+ "message": "ค่า SHA-256 ที่คาดไว้ของไฟล์ zip: $1"
+ },
+ "setReachTitle": {
+ "message": "สิ่งที่เข้าถึงได้"
+ },
+ "setReachSub": {
+ "message": "เฉพาะโฟลเดอร์ข้างบน และเฉพาะไฟล์ที่หน้านั้นถูกเปิดขึ้นมาจริง ๆ ไม่มีการอัปโหลดสิ่งใด และไม่มีการอ่านที่อื่น"
+ },
+ "updateAvailable": {
+ "message": "<b>มี Bento Tray $1 ให้ใช้แล้ว</b> สำเนานี้โหลดแบบไม่บีบอัด Chrome จึงไม่อัปเดตให้เลย"
+ },
+ "updateStep1": {
+ "message": "ดาวน์โหลดจาก GitHub"
+ },
+ "updateStep2": {
+ "message": "แทนที่ไฟล์ <b>ในโฟลเดอร์ที่คุณโหลดมันมา</b> — ต้องเป็นโฟลเดอร์เดิม มิฉะนั้น Chrome จะถือว่าเป็นส่วนขยายคนละตัว และโฟลเดอร์ที่ให้สิทธิ์ไว้จะไม่ตามไปด้วย"
+ },
+ "updateStep3": {
+ "message": "เปิด <code>chrome://extensions</code> แล้วกด <b>โหลดซ้ำ</b> ที่ Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "กำลังดึง $1…"
+ },
+ "createdIn": {
+ "message": "สร้าง $1 ($2) ใน $3 แล้ว"
+ },
+ "intoFolder": {
+ "message": "ลงใน $1"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray ทำอะไร"
+ },
+ "helpWhatSub": {
+ "message": "เอกสาร Bento คือไฟล์ HTML ไฟล์เดียวที่พกตัวแก้ไขของตัวเองมาด้วย เมื่อเปิดตรงจากดิสก์ เบราว์เซอร์จะไม่ยอมให้มันเขียนกลับลงตัวเอง — การบันทึกจึงถามปลายทางทุกครั้ง Bento Tray คือสิ่งที่ตัดคำถามนั้นออกไป"
+ },
+ "tourSaveTitle": {
+ "message": "บันทึกทับที่เดิม"
+ },
+ "tourSaveBody": {
+ "message": "⌘S เขียนกลับลงไฟล์ที่คุณเปิดโดยตรง ไม่มีกล่องโต้ตอบ การบันทึกอัตโนมัติและการอัปเดตทับที่เดิมก็ไปทางเดียวกัน"
+ },
+ "tourFindTitle": {
+ "message": "ค้นหาเอกสารของคุณ"
+ },
+ "tourFindBody": {
+ "message": "เอกสาร Bento ทุกฉบับในโฟลเดอร์ของคุณ พร้อมชื่อเรื่องจริงและภาพหน้าแรก การค้นหาครอบคลุมถึงสิ่งที่เขียนอยู่ข้างในด้วย"
+ },
+ "tourSwitchTitle": {
+ "message": "สลับไปมาระหว่างทำงาน"
+ },
+ "tourSwitchBody": {
+ "message": "กด <kbd>Alt</kbd>+<kbd>B</kbd> หรือคลิกขวาในเอกสาร เพื่อเปิดแผงข้าง ๆ"
+ },
+ "tourNewTitle": {
+ "message": "สร้างฉบับใหม่"
+ },
+ "tourNewBody": {
+ "message": "<b>+ เอกสารใหม่</b> ดึงรุ่นปัจจุบันของ Slides, Spaces หรือ Dash มา แล้ววางเอกสารใหม่ไว้ในโฟลเดอร์ของคุณ"
+ },
+ "helpNeedsTitle": {
+ "message": "สิ่งที่ต้องขอจากคุณ"
+ },
+ "helpNeedsSub": {
+ "message": "สองอย่าง ซึ่งทั้งคู่อยู่นอกอำนาจที่ส่วนขยายนี้จะจัดการเองได้"
+ },
+ "helpFolder": {
+ "message": "โฟลเดอร์หนึ่ง"
+ },
+ "helpFolderGranted": {
+ "message": "ให้สิทธิ์แล้ว $1 — เอกสารข้างในบันทึกทับที่เดิม"
+ },
+ "helpFolderNone": {
+ "message": "ยังไม่ได้เลือก โฟลเดอร์กว้าง ๆ หนึ่งโฟลเดอร์ครอบคลุมทุกอย่างที่อยู่ข้างใน"
+ },
+ "helpAccessOff": {
+ "message": "ปิด เปิด <b>อนุญาตให้เข้าถึง URL ของไฟล์</b> ใน <code>chrome://extensions</code> — ไม่มีส่วนขยายใดเปิดสิ่งนี้ด้วยตัวเองได้"
+ },
+ "helpAccessUnknown": {
+ "message": "เบราว์เซอร์นี้ไม่รายงานสถานะ ถ้าการบันทึกยังถามอยู่ ให้ตรวจสอบใน <code>chrome://extensions</code>"
+ },
+ "helpAccessOn": {
+ "message": "เปิด — Bento Tray อ่านหน้าที่คุณเปิดจากดิสก์ได้"
+ },
+ "helpNeverTitle": {
+ "message": "สิ่งที่มันไม่เคยทำ"
+ },
+ "helpNeverSub": {
+ "message": "มันอ่านและเขียนเฉพาะภายในโฟลเดอร์ข้างบน และเฉพาะไฟล์ที่หน้านั้นถูกเปิดขึ้นมาจริง ๆ — เบราว์เซอร์เป็นผู้บอกว่าไฟล์ใด เอกสารจึงไม่อาจระบุไฟล์ของคนอื่นได้ ไม่มีอะไรเกี่ยวกับเอกสารของคุณถูกอัปโหลดไปที่ใด และส่วนขยายนี้ก็ไม่มีเซิร์ฟเวอร์ให้อัปโหลดไปตั้งแต่แรก"
+ },
+ "helpAboutTitle": {
+ "message": "เกี่ยวกับ"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · ส่วนหนึ่งของโครงการ Bento · สัญญาอนุญาต MIT"
+ },
+ "linkSource": {
+ "message": "ซอร์สโค้ดบน GitHub"
+ },
+ "linkIssues": {
+ "message": "แจ้งปัญหา"
+ },
+ "linkReleases": {
+ "message": "รุ่นที่เผยแพร่"
+ },
+ "primeMiddle": {
+ "message": "ตัวเลือกที่คงอยู่"
+ },
+ "primeNote": {
+ "message": "อีกสองตัวเลือกก็ใช้ได้ แต่ Chrome จะถามอีก — ตัวแรกถามทุกครั้งที่เริ่มใหม่ ส่วนตัวสุดท้ายถามหลังจากรอไประยะหนึ่ง"
+ }
+}
diff --git a/tray/webext/_locales/tr/messages.json b/tray/webext/_locales/tr/messages.json
new file mode 100644
index 00000000..0809eafe
--- /dev/null
+++ b/tray/webext/_locales/tr/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Bir Bento belgesini, hedef sorulmadan açtığınız dosyaya geri kaydedin."
+ },
+ "navAll": {
+ "message": "Tüm belgeler"
+ },
+ "navFolders": {
+ "message": "Klasörler"
+ },
+ "navHelp": {
+ "message": "Yardım ve hakkında"
+ },
+ "navSettings": {
+ "message": "Ayarlar"
+ },
+ "addFolder": {
+ "message": "+ Klasör ekle…"
+ },
+ "searchDocs": {
+ "message": "Belgelerde ara"
+ },
+ "searchDocsSlash": {
+ "message": "Belgelerde ara /"
+ },
+ "sortTitle": {
+ "message": "Sırala"
+ },
+ "sortRecent": {
+ "message": "Son değiştirilen"
+ },
+ "sortName": {
+ "message": "Ad"
+ },
+ "sortFolder": {
+ "message": "Klasör"
+ },
+ "newDocument": {
+ "message": "+ Yeni belge"
+ },
+ "browseAll": {
+ "message": "Tümüne göz at"
+ },
+ "reconnectFolders": {
+ "message": "Klasörleri yeniden bağla"
+ },
+ "primeIntro": {
+ "message": "Chrome birazdan soracak. Ortadaki seçeneği seçin:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — bir klasörün yeniden bağlanması gerekiyor"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray'in yeniden bağlanması gerekiyor"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome bir klasörün iznini geri aldı. İzin geri verilene kadar her kaydetme, dosyanın nereye konacağını soracak."
+ },
+ "reconnect": {
+ "message": "Yeniden bağla"
+ },
+ "ctxOpenPanel": {
+ "message": "Bento Tray panelini aç"
+ },
+ "panelEmpty": {
+ "message": "Klasörlerinizde henüz Bento belgesi yok."
+ },
+ "noMatches": {
+ "message": "“$1” ile eşleşen bir şey yok"
+ },
+ "rowUnplacedTip": {
+ "message": "$1 içindeki herhangi bir belgeyi Finder'dan bir kez açın; o klasördeki her şey buradan açılabilir hale gelir."
+ },
+ "encrypted": {
+ "message": "Parola korumalı"
+ },
+ "notSavedYet": {
+ "message": "Henüz kaydedilmedi"
+ },
+ "fileAccessOffShort": {
+ "message": "Yerel dosya erişimi kapalı"
+ },
+ "noFoldersYet": {
+ "message": "Henüz klasör yok"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 klasörün yeniden bağlanması gerekiyor"
+ },
+ "statusOneFolder": {
+ "message": "$1 klasör · yerinde kaydeder"
+ },
+ "statusFolders": {
+ "message": "$1 klasör · yerinde kaydeder"
+ },
+ "renewNotOffered": {
+ "message": "Chrome geri yüklemeyi önermedi"
+ },
+ "renewTryAfterRestart": {
+ "message": "Chrome'u yeniden başlattıktan sonra tekrar deneyin"
+ },
+ "fetchingLatest": {
+ "message": "En son Bento alınıyor…"
+ },
+ "created": {
+ "message": "$1 oluşturuldu"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 okunabiliyor ama henüz açılamıyor — Chrome bir uzantıya bir klasörün diskte nerede olduğunu söylemez. <b>Tümüne göz at</b> onları tek tıkla bulur."
+ },
+ "andMore": {
+ "message": " ve $1 tane daha"
+ },
+ "agoJustNow": {
+ "message": "az önce"
+ },
+ "agoMinutes": {
+ "message": "$1 dk önce"
+ },
+ "agoHour": {
+ "message": "$1 saat önce"
+ },
+ "agoHours": {
+ "message": "$1 saat önce"
+ },
+ "agoDay": {
+ "message": "$1 gün önce"
+ },
+ "agoDays": {
+ "message": "$1 gün önce"
+ },
+ "searchScope": {
+ "message": "Arama; başlıklara, dosya adlarına, klasörlere ve belgelerin içindeki sözcüklere bakar."
+ },
+ "folderEmpty": {
+ "message": "Bu klasörde henüz bir şey yok"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Yeni belge</b> buraya yeni bir tane koyar."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray, $1 klasörünün diskte nerede olduğunu henüz bilmiyor. “Klasörlerimi bul”u kullanın ya da içindeki bir belgeyi Finder'dan bir kez açın."
+ },
+ "cardRenamedTip": {
+ "message": "$1, başka bir adla kaydedilmiş bir Bento belgesidir. Buradan açılır, ancak kaydetme bir hedef soracaktır — yerinde kaydetme yalnızca .bento.html ile biten dosyaları tanır."
+ },
+ "badgeRenamed": {
+ "message": ".bento.html yerine .html olarak adlandırılmış — buradan açılır, ancak kaydetme bir hedef soracaktır."
+ },
+ "menuOpen": {
+ "message": "Aç"
+ },
+ "menuDuplicate": {
+ "message": "Çoğalt"
+ },
+ "menuRename": {
+ "message": "Yeniden adlandır…"
+ },
+ "menuCopyPath": {
+ "message": "Yolu kopyala"
+ },
+ "duplicatedAs": {
+ "message": "$1 olarak çoğaltıldı"
+ },
+ "renamePrompt": {
+ "message": "Belgeyi yeniden adlandır"
+ },
+ "renamedTo": {
+ "message": "$1 olarak yeniden adlandırıldı"
+ },
+ "pathCopied": {
+ "message": "Yol kopyalandı"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — henüz açılmadı"
+ },
+ "setupTitle": {
+ "message": "İki şey ve hazırsınız"
+ },
+ "setupLead": {
+ "message": "Bundan sonra, çift tıklayarak açtığınız bir belgede ⌘S doğrudan dosyaya yazar — bir daha asla hedef sorulmaz."
+ },
+ "chooseFolder": {
+ "message": "Klasör seç…"
+ },
+ "setupStep1": {
+ "message": "Belgelerinizin bulunduğu klasörü seçin"
+ },
+ "setupStep1Note": {
+ "message": "Genelde geniş tek bir klasör yeter — içindeki her şeyi kapsar."
+ },
+ "setupStep2": {
+ "message": "Yerel dosya erişimini açın"
+ },
+ "setupStep2Note": {
+ "message": "<code>chrome://extensions</code> → Bento Tray → <b>Dosya URL'lerine erişime izin ver</b>. Chrome, bir uzantının bunu kendi başına açmasına izin vermez."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Yükselttiniz ve klasörlerinizi burada mı bekliyordunuz?</b> Paketlenmemiş bir uzantı klasör yoluyla tanınır, dolayısıyla başka bir klasörden yüklenen yeni bir kopya farklı bir uzantıdır. Klasörleriniz hâlâ eskisine bağlı. Bunun yerine özgün klasördeki dosyaları değiştirin ve <code>chrome://extensions</code> içinde <b>Yeniden yükle</b>ye basın."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Yerel dosya erişimi kapalı</b> — açılana kadar hiçbir şey yerinde kaydedilmez. <code>chrome://extensions</code> içinde <b>Dosya URL'lerine erişime izin ver</b>i açın."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 klasörün yeniden bağlanması gerekiyor.</b> <b>Ayarlar</b>'dan yeniden bağlayın ve <b>Her ziyarette izin ver</b>i seçin — kalıcı olan tek seçenek budur."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> listelenebiliyor ama henüz açılamıyor — Chrome bir uzantıya bir klasörün diskte nerede olduğunu asla söylemez."
+ },
+ "findFolders": {
+ "message": "Klasörlerimi bul"
+ },
+ "looking": {
+ "message": "Aranıyor…"
+ },
+ "findDeclined": {
+ "message": "<b>Sorun değil.</b> Bunun yerine $1 içindeki bir belgeyi Finder'dan bir kez açın — bu sayfa fark eder."
+ },
+ "foundFolder": {
+ "message": "$1 klasör bulundu"
+ },
+ "foundFolders": {
+ "message": "$1 klasör bulundu"
+ },
+ "foundNothing": {
+ "message": "Geçmişte henüz bir şey yok — Finder'dan bir belge açın"
+ },
+ "setFoldersSub": {
+ "message": "Bunların içindeki belgeler, hedef sorulmadan doğrudan dosyaya geri kaydedilir. Bir klasör içindeki her şeyi kapsar."
+ },
+ "noneYet": {
+ "message": "Henüz yok."
+ },
+ "savesInPlace": {
+ "message": "yerinde kaydeder"
+ },
+ "needsReconnecting": {
+ "message": "yeniden bağlanması gerekiyor"
+ },
+ "reconnectTip": {
+ "message": "Chrome bu klasörü geri yüklemek için soracak. “İzin verme” onu bırakır ve Chrome sonrasında yeniden sormadan önce en az bir yeniden başlatma bekler."
+ },
+ "remove": {
+ "message": "Kaldır"
+ },
+ "removeTip": {
+ "message": "Erişimi geri alır. Chrome izni yine de hatırlayabilir, bu yüzden klasörü geri eklemek yeniden sormayabilir."
+ },
+ "setAccessTitle": {
+ "message": "Yerel dosya erişimi"
+ },
+ "setAccessSub": {
+ "message": "Chrome bir uzantının bunu kendi başına açmasına izin vermez ve bu olmadan hiçbir şey çalışmaz."
+ },
+ "stateOn": {
+ "message": "Açık"
+ },
+ "stateOff": {
+ "message": "Kapalı"
+ },
+ "stateUnknown": {
+ "message": "Bilinmiyor"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray, diskten açtığınız sayfaları okuyabilir."
+ },
+ "accessOffNote": {
+ "message": "chrome://extensions'ı açın, Bento Tray'i bulun, “Dosya URL'lerine erişime izin ver”i açın."
+ },
+ "accessUnknownNote": {
+ "message": "Bu tarayıcı bunu bildirmiyor. Kaydetme hâlâ soruyorsa chrome://extensions'tan kontrol edin."
+ },
+ "setVersionTitle": {
+ "message": "Sürüm"
+ },
+ "setVersionUnpacked": {
+ "message": "Bu kopya paketlenmemiş olarak yüklendi, bu yüzden Chrome onu asla güncellemez."
+ },
+ "setVersionStore": {
+ "message": "Mağazadan kuruldu, bu yüzden kendini günceller."
+ },
+ "versionAvailable": {
+ "message": "$1 mevcut"
+ },
+ "versionUpToDate": {
+ "message": "son kontrole göre güncel"
+ },
+ "versionManaged": {
+ "message": "tarayıcı tarafından güncel tutuluyor"
+ },
+ "getIt": {
+ "message": "İndir"
+ },
+ "checkNow": {
+ "message": "Şimdi denetle"
+ },
+ "autoCheckPref": {
+ "message": "<b>Tarayıcı başlarken yeni sürüm olup olmadığını denetle.</b><br>bento.page'e statik bir dosya için tek bir istek. Hiçbir tanımlayıcı, sürüm numarası ya da belgelerinizle ilgili bir şey göndermez — karşılaştırma burada yapılır. Kapatın, hiçbir zaman istek gönderilmez; <b>Şimdi denetle</b> yine çalışır."
+ },
+ "expectedSha": {
+ "message": "Zip dosyasının beklenen SHA-256 değeri: $1"
+ },
+ "setReachTitle": {
+ "message": "Bunun erişebildikleri"
+ },
+ "setReachSub": {
+ "message": "Yalnızca yukarıdaki klasörler ve yalnızca bir sayfanın gerçekten açıldığı dosya. Hiçbir şey yüklenmez ve başka hiçbir yerde bir şey okunmaz."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 mevcut.</b> Bu kopya paketlenmemiş olarak yüklendi, bu yüzden Chrome onu asla güncellemez."
+ },
+ "updateStep1": {
+ "message": "GitHub'dan indirin"
+ },
+ "updateStep2": {
+ "message": "Dosyaları <b>onu yüklediğiniz klasörde</b> değiştirin — aynı klasör olmalı, yoksa Chrome bunu farklı bir uzantı sayar ve izin verdiğiniz klasörler onunla gelmez"
+ },
+ "updateStep3": {
+ "message": "<code>chrome://extensions</code>'ı açın ve Bento Tray'de <b>Yeniden yükle</b>ye basın"
+ },
+ "fetchingApp": {
+ "message": "$1 alınıyor…"
+ },
+ "createdIn": {
+ "message": "$3 içinde $1 ($2) oluşturuldu"
+ },
+ "intoFolder": {
+ "message": "$1 içine"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray ne yapar"
+ },
+ "helpWhatSub": {
+ "message": "Bir Bento belgesi, kendi düzenleyicisini taşıyan tek bir HTML dosyasıdır. Doğrudan diskten açıldığında tarayıcı kendine geri yazmasına izin vermez — bu yüzden kaydetme her seferinde nereye konacağını sorar. Bento Tray bu soruyu ortadan kaldırır."
+ },
+ "tourSaveTitle": {
+ "message": "Yerinde kaydet"
+ },
+ "tourSaveBody": {
+ "message": "⌘S, iletişim kutusu olmadan doğrudan açtığınız dosyaya yazar. Otomatik kaydetme ve yerinde güncellemeler de aynı yolu izler."
+ },
+ "tourFindTitle": {
+ "message": "Belgelerinizi bulun"
+ },
+ "tourFindBody": {
+ "message": "Klasörlerinizdeki her Bento belgesi, gerçek başlığı ve ilk sayfasının görüntüsüyle birlikte. Arama, içlerinde yazılanları da kapsar."
+ },
+ "tourSwitchTitle": {
+ "message": "Çalışırken geçiş yapın"
+ },
+ "tourSwitchBody": {
+ "message": "Yanında bir panel için <kbd>Alt</kbd>+<kbd>B</kbd>'ye basın ya da bir belgenin içine sağ tıklayın."
+ },
+ "tourNewTitle": {
+ "message": "Yeni bir tane oluşturun"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Yeni belge</b>, Slides, Spaces ya da Dash'in güncel sürümünü alır ve klasörünüze yeni bir belge koyar."
+ },
+ "helpNeedsTitle": {
+ "message": "Sizden ne istiyor"
+ },
+ "helpNeedsSub": {
+ "message": "İki şey; ikisi de bu uzantının kendi başına halledebileceği şeyler değil."
+ },
+ "helpFolder": {
+ "message": "Bir klasör"
+ },
+ "helpFolderGranted": {
+ "message": "$1 izin verildi — içlerindeki belgeler yerinde kaydedilir"
+ },
+ "helpFolderNone": {
+ "message": "Henüz seçilmedi. Geniş tek bir klasör içindeki her şeyi kapsar."
+ },
+ "helpAccessOff": {
+ "message": "Kapalı. <code>chrome://extensions</code> içinde <b>Dosya URL'lerine erişime izin ver</b>i açın — hiçbir uzantı bunu kendi başına açamaz."
+ },
+ "helpAccessUnknown": {
+ "message": "Bu tarayıcı bunu bildirmiyor. Kaydetme hâlâ soruyorsa <code>chrome://extensions</code>'tan kontrol edin."
+ },
+ "helpAccessOn": {
+ "message": "Açık — Bento Tray, diskten açtığınız sayfaları okuyabilir."
+ },
+ "helpNeverTitle": {
+ "message": "Asla yapmadıkları"
+ },
+ "helpNeverSub": {
+ "message": "Yalnızca yukarıdaki klasörlerin içinde ve yalnızca bir sayfanın gerçekten açıldığı dosyada okur ve yazar — hangisi olduğunu tarayıcı söyler, dolayısıyla bir belge başkasının dosyasını gösteremez. Belgelerinizle ilgili hiçbir şey hiçbir yere yüklenmez ve uzantının onları yükleyeceği bir sunucusu yoktur."
+ },
+ "helpAboutTitle": {
+ "message": "Hakkında"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · Bento projesinin parçası · MIT lisanslı"
+ },
+ "linkSource": {
+ "message": "GitHub'da kaynak"
+ },
+ "linkIssues": {
+ "message": "Sorun bildir"
+ },
+ "linkReleases": {
+ "message": "Sürümler"
+ },
+ "primeMiddle": {
+ "message": "kalıcı olan"
+ },
+ "primeNote": {
+ "message": "Diğer ikisi de çalışır, ama Chrome yeniden sorar — ilki için her yeniden başlatmada, sonuncusu için bir bekleme sonrasında."
+ }
+}
diff --git a/tray/webext/_locales/uk/messages.json b/tray/webext/_locales/uk/messages.json
new file mode 100644
index 00000000..e12fb3e1
--- /dev/null
+++ b/tray/webext/_locales/uk/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Зберігайте документ Bento назад у відкритий файл, без запитання про місце збереження."
+ },
+ "navAll": {
+ "message": "Усі документи"
+ },
+ "navFolders": {
+ "message": "Папки"
+ },
+ "navHelp": {
+ "message": "Довідка та про програму"
+ },
+ "navSettings": {
+ "message": "Налаштування"
+ },
+ "addFolder": {
+ "message": "+ Додати папку…"
+ },
+ "searchDocs": {
+ "message": "Пошук у документах"
+ },
+ "searchDocsSlash": {
+ "message": "Пошук у документах /"
+ },
+ "sortTitle": {
+ "message": "Сортування"
+ },
+ "sortRecent": {
+ "message": "Нещодавно змінені"
+ },
+ "sortName": {
+ "message": "Назва"
+ },
+ "sortFolder": {
+ "message": "Папка"
+ },
+ "newDocument": {
+ "message": "+ Новий документ"
+ },
+ "browseAll": {
+ "message": "Показати всі"
+ },
+ "reconnectFolders": {
+ "message": "Перепідключити папки"
+ },
+ "primeIntro": {
+ "message": "Зараз Chrome запитає. Оберіть середній варіант:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — папку треба перепідключити"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray треба перепідключити"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome скасував дозвіл на папку. Доки його не відновлено, кожне збереження питатиме, куди покласти файл."
+ },
+ "reconnect": {
+ "message": "Перепідключити"
+ },
+ "ctxOpenPanel": {
+ "message": "Відкрити панель Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "У ваших папках ще немає документів Bento."
+ },
+ "noMatches": {
+ "message": "Нічого не знайдено за запитом «$1»"
+ },
+ "rowUnplacedTip": {
+ "message": "Відкрийте будь-який документ у $1 один раз із Finder — і все в цій папці можна буде відкривати звідси."
+ },
+ "encrypted": {
+ "message": "Захищений паролем"
+ },
+ "notSavedYet": {
+ "message": "Ще не збережено"
+ },
+ "fileAccessOffShort": {
+ "message": "Доступ до локальних файлів вимкнено"
+ },
+ "noFoldersYet": {
+ "message": "Папок ще немає"
+ },
+ "foldersNeedReconnect": {
+ "message": "Папок треба перепідключити: $1"
+ },
+ "statusOneFolder": {
+ "message": "папок: $1 · зберігає на місці"
+ },
+ "statusFolders": {
+ "message": "папок: $1 · зберігають на місці"
+ },
+ "renewNotOffered": {
+ "message": "Chrome не запропонував її відновити"
+ },
+ "renewTryAfterRestart": {
+ "message": "Спробуйте ще раз після перезапуску Chrome"
+ },
+ "fetchingLatest": {
+ "message": "Завантажується найновіший Bento…"
+ },
+ "created": {
+ "message": "Створено: $1"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 можна прочитати, але ще не відкрити — Chrome не повідомляє розширенню, де папка на диску. <b>Показати всі</b> знайде їх одним кліком."
+ },
+ "andMore": {
+ "message": " і ще $1"
+ },
+ "agoJustNow": {
+ "message": "щойно"
+ },
+ "agoMinutes": {
+ "message": "$1 хв тому"
+ },
+ "agoHour": {
+ "message": "$1 год тому"
+ },
+ "agoHours": {
+ "message": "$1 год тому"
+ },
+ "agoDay": {
+ "message": "$1 дн. тому"
+ },
+ "agoDays": {
+ "message": "$1 дн. тому"
+ },
+ "searchScope": {
+ "message": "Пошук дивиться на заголовки, назви файлів, папки та слова всередині документів."
+ },
+ "folderEmpty": {
+ "message": "У цій папці ще порожньо"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Новий документ</b> створить тут новий."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray ще не знає, де $1 на диску. Скористайтеся «Знайти мої папки» або один раз відкрийте з Finder будь-який документ звідти."
+ },
+ "cardRenamedTip": {
+ "message": "$1 — це документ Bento під іншою назвою. Він відкривається звідси, але збереження запитає місце — збереження на місці розпізнає лише файли, що закінчуються на .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Названо .html, а не .bento.html — відкривається звідси, але збереження запитає місце."
+ },
+ "menuOpen": {
+ "message": "Відкрити"
+ },
+ "menuDuplicate": {
+ "message": "Дублювати"
+ },
+ "menuRename": {
+ "message": "Перейменувати…"
+ },
+ "menuCopyPath": {
+ "message": "Копіювати шлях"
+ },
+ "duplicatedAs": {
+ "message": "Дубльовано як $1"
+ },
+ "renamePrompt": {
+ "message": "Перейменувати документ"
+ },
+ "renamedTo": {
+ "message": "Перейменовано на $1"
+ },
+ "pathCopied": {
+ "message": "Шлях скопійовано"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — ще не відкривалася"
+ },
+ "setupTitle": {
+ "message": "Дві речі — і все готово"
+ },
+ "setupLead": {
+ "message": "Після цього ⌘S у документі, відкритому подвійним клацанням, пише прямо у файл — питання про місце більше ніколи не з’явиться."
+ },
+ "chooseFolder": {
+ "message": "Вибрати папку…"
+ },
+ "setupStep1": {
+ "message": "Виберіть папку, де лежать ваші документи"
+ },
+ "setupStep1Note": {
+ "message": "Зазвичай досить однієї широкої папки — вона охоплює все всередині."
+ },
+ "setupStep2": {
+ "message": "Увімкніть доступ до локальних файлів"
+ },
+ "setupStep2Note": {
+ "message": "У <code>chrome://extensions</code> → Bento Tray → <b>Дозволити доступ до URL файлів</b>. Chrome не дає розширенню увімкнути це самостійно."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Оновилися й очікували побачити тут свої папки?</b> Розпаковане розширення розпізнається за шляхом до папки, тож нова копія, завантажена з іншої папки, — це інше розширення. Ваші папки досі належать старому. Замість цього замініть файли у початковій папці й натисніть <b>Оновити</b> в <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Доступ до локальних файлів вимкнено</b> — доки він вимкнений, ніщо не збережеться на місці. Увімкніть <b>Дозволити доступ до URL файлів</b> у <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>Папок треба перепідключити: $1.</b> Перепідключіть у <b>Налаштуваннях</b> і оберіть <b>Дозволяти щоразу</b> — єдиний варіант, який зберігається."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> можна показати у списку, але ще не відкрити — Chrome ніколи не повідомляє розширенню, де папка на диску."
+ },
+ "findFolders": {
+ "message": "Знайти мої папки"
+ },
+ "looking": {
+ "message": "Триває пошук…"
+ },
+ "findDeclined": {
+ "message": "<b>Нічого страшного.</b> Тоді один раз відкрийте з Finder будь-який документ у $1 — ця сторінка помітить."
+ },
+ "foundFolder": {
+ "message": "Знайдено папку: $1"
+ },
+ "foundFolders": {
+ "message": "Знайдено папок: $1"
+ },
+ "foundNothing": {
+ "message": "В історії ще порожньо — відкрийте один документ із Finder"
+ },
+ "setFoldersSub": {
+ "message": "Документи звідси зберігаються прямо у файл, без запитання про місце. Папка охоплює все всередині."
+ },
+ "noneYet": {
+ "message": "Поки немає."
+ },
+ "savesInPlace": {
+ "message": "зберігає на місці"
+ },
+ "needsReconnecting": {
+ "message": "треба перепідключити"
+ },
+ "reconnectTip": {
+ "message": "Chrome запитає про відновлення цієї папки. «Не дозволяти» скидає її, і після цього Chrome чекає щонайменше перезапуску, перш ніж запитати знову."
+ },
+ "remove": {
+ "message": "Видалити"
+ },
+ "removeTip": {
+ "message": "Забирає доступ. Chrome може пам’ятати дозвіл, тож повторне додавання папки може й не запитати."
+ },
+ "setAccessTitle": {
+ "message": "Доступ до локальних файлів"
+ },
+ "setAccessSub": {
+ "message": "Chrome не дає розширенню увімкнути це самостійно, а без цього ніщо не працює."
+ },
+ "stateOn": {
+ "message": "Увімк."
+ },
+ "stateOff": {
+ "message": "Вимк."
+ },
+ "stateUnknown": {
+ "message": "Невідомо"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray може читати сторінки, відкриті з диска."
+ },
+ "accessOffNote": {
+ "message": "Відкрийте chrome://extensions, знайдіть Bento Tray і увімкніть «Дозволити доступ до URL файлів»."
+ },
+ "accessUnknownNote": {
+ "message": "Цей браузер не повідомляє стан. Якщо збереження досі питає, перевірте в chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Версія"
+ },
+ "setVersionUnpacked": {
+ "message": "Ця копія завантажена розпакованою, тож Chrome ніколи її не оновить."
+ },
+ "setVersionStore": {
+ "message": "Встановлено з магазину, тож оновлюється саме."
+ },
+ "versionAvailable": {
+ "message": "Доступна версія $1"
+ },
+ "versionUpToDate": {
+ "message": "актуально станом на останню перевірку"
+ },
+ "versionManaged": {
+ "message": "підтримується в актуальному стані браузером"
+ },
+ "getIt": {
+ "message": "Отримати"
+ },
+ "checkNow": {
+ "message": "Перевірити зараз"
+ },
+ "autoCheckPref": {
+ "message": "<b>Перевіряти нову версію під час запуску браузера.</b><br>Один запит до bento.page по статичний файл. Він не надсилає ідентифікаторів, номера версії й нічого про ваші документи — порівняння відбувається тут. Вимкніть — і запитів не буде взагалі; <b>Перевірити зараз</b> працюватиме й далі."
+ },
+ "expectedSha": {
+ "message": "Очікуваний SHA-256 архіву: $1"
+ },
+ "setReachTitle": {
+ "message": "До чого є доступ"
+ },
+ "setReachSub": {
+ "message": "Лише до папок вище і лише до того файлу, з якого справді відкрито сторінку. Нічого не вивантажується і ніде більше нічого не читається."
+ },
+ "updateAvailable": {
+ "message": "<b>Доступна Bento Tray $1.</b> Ця копія завантажена розпакованою, тож Chrome ніколи її не оновить."
+ },
+ "updateStep1": {
+ "message": "Завантажте з GitHub"
+ },
+ "updateStep2": {
+ "message": "Замініть файли <b>у тій папці, з якої завантажували</b> — саме в тій самій, інакше Chrome вважатиме це іншим розширенням, і надані папки за ним не підуть"
+ },
+ "updateStep3": {
+ "message": "Відкрийте <code>chrome://extensions</code> і натисніть <b>Оновити</b> в Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Завантажується $1…"
+ },
+ "createdIn": {
+ "message": "Створено $1 ($2) у $3"
+ },
+ "intoFolder": {
+ "message": "у $1"
+ },
+ "helpWhatTitle": {
+ "message": "Що робить Bento Tray"
+ },
+ "helpWhatSub": {
+ "message": "Документ Bento — це один HTML-файл, що несе власний редактор. Відкритий просто з диска, він не може записати сам у себе — тож збереження щоразу питає, куди покласти файл. Bento Tray прибирає це питання."
+ },
+ "tourSaveTitle": {
+ "message": "Збереження на місці"
+ },
+ "tourSaveBody": {
+ "message": "⌘S пише прямо у відкритий файл, без діалогу. Автозбереження та оновлення на місці йдуть тим самим шляхом."
+ },
+ "tourFindTitle": {
+ "message": "Знайдіть свої документи"
+ },
+ "tourFindBody": {
+ "message": "Кожен документ Bento у ваших папках, зі справжнім заголовком і зображенням першої сторінки. Пошук охоплює й те, що написано всередині."
+ },
+ "tourSwitchTitle": {
+ "message": "Перемикайтеся під час роботи"
+ },
+ "tourSwitchBody": {
+ "message": "Натисніть <kbd>Alt</kbd>+<kbd>B</kbd> або клацніть правою кнопкою всередині документа — панель відкриється поруч."
+ },
+ "tourNewTitle": {
+ "message": "Створіть новий"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Новий документ</b> завантажує поточний випуск Slides, Spaces або Dash і кладе новий документ у вашу папку."
+ },
+ "helpNeedsTitle": {
+ "message": "Що йому потрібно від вас"
+ },
+ "helpNeedsSub": {
+ "message": "Дві речі, жодну з яких це розширення не може влаштувати саме."
+ },
+ "helpFolder": {
+ "message": "Папка"
+ },
+ "helpFolderGranted": {
+ "message": "надано: $1 — документи всередині зберігаються на місці"
+ },
+ "helpFolderNone": {
+ "message": "Ще не вибрано. Одна широка папка охоплює все всередині."
+ },
+ "helpAccessOff": {
+ "message": "Вимк. Увімкніть <b>Дозволити доступ до URL файлів</b> у <code>chrome://extensions</code> — жодне розширення не може увімкнути це саме."
+ },
+ "helpAccessUnknown": {
+ "message": "Цей браузер не повідомляє стан. Якщо збереження досі питає, перевірте в <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Увімк. — Bento Tray може читати сторінки, відкриті з диска."
+ },
+ "helpNeverTitle": {
+ "message": "Чого воно ніколи не робить"
+ },
+ "helpNeverSub": {
+ "message": "Воно читає й пише лише всередині папок вище і лише той файл, з якого справді відкрито сторінку — який саме, повідомляє браузер, тож документ не може назвати чужий файл. Нічого про ваші документи нікуди не вивантажується, і в розширення немає сервера, куди їх можна було б вивантажити."
+ },
+ "helpAboutTitle": {
+ "message": "Про програму"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · частина проєкту Bento · ліцензія MIT"
+ },
+ "linkSource": {
+ "message": "Код на GitHub"
+ },
+ "linkIssues": {
+ "message": "Повідомити про проблему"
+ },
+ "linkReleases": {
+ "message": "Випуски"
+ },
+ "primeMiddle": {
+ "message": "той, який зберігається"
+ },
+ "primeNote": {
+ "message": "Два інші теж працюють, але Chrome запитає знову — перший при кожному перезапуску, останній після очікування."
+ }
+}
diff --git a/tray/webext/_locales/ur/messages.json b/tray/webext/_locales/ur/messages.json
new file mode 100644
index 00000000..64449f57
--- /dev/null
+++ b/tray/webext/_locales/ur/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Bento دستاویز کو اُسی فائل میں واپس محفوظ کریں جو آپ نے کھولی تھی، منزل پوچھے بغیر۔"
+ },
+ "navAll": {
+ "message": "تمام دستاویزات"
+ },
+ "navFolders": {
+ "message": "فولڈرز"
+ },
+ "navHelp": {
+ "message": "مدد اور تعارف"
+ },
+ "navSettings": {
+ "message": "ترتیبات"
+ },
+ "addFolder": {
+ "message": "+ فولڈر شامل کریں…"
+ },
+ "searchDocs": {
+ "message": "دستاویزات میں تلاش کریں"
+ },
+ "searchDocsSlash": {
+ "message": "دستاویزات میں تلاش کریں /"
+ },
+ "sortTitle": {
+ "message": "ترتیب"
+ },
+ "sortRecent": {
+ "message": "حال ہی میں تبدیل شدہ"
+ },
+ "sortName": {
+ "message": "نام"
+ },
+ "sortFolder": {
+ "message": "فولڈر"
+ },
+ "newDocument": {
+ "message": "+ نئی دستاویز"
+ },
+ "browseAll": {
+ "message": "سب دیکھیں"
+ },
+ "reconnectFolders": {
+ "message": "فولڈرز دوبارہ جوڑیں"
+ },
+ "primeIntro": {
+ "message": "Chrome ابھی پوچھے گا۔ درمیان والا اختیار منتخب کریں:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — ایک فولڈر کو دوبارہ جوڑنا ہے"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray کو دوبارہ جوڑنا ہے"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome نے ایک فولڈر کی اجازت واپس لے لی۔ جب تک بحال نہ ہو، ہر بار محفوظ کرنے پر پوچھا جائے گا کہ فائل کہاں رکھی جائے۔"
+ },
+ "reconnect": {
+ "message": "دوبارہ جوڑیں"
+ },
+ "ctxOpenPanel": {
+ "message": "Bento Tray پینل کھولیں"
+ },
+ "panelEmpty": {
+ "message": "آپ کے فولڈرز میں ابھی کوئی Bento دستاویز نہیں۔"
+ },
+ "noMatches": {
+ "message": "”$1“ سے کچھ مماثل نہیں"
+ },
+ "rowUnplacedTip": {
+ "message": "$1 کی کوئی ایک دستاویز Finder سے ایک بار کھول لیں، پھر اُس فولڈر کی ہر چیز یہیں سے کھلنے لگے گی۔"
+ },
+ "encrypted": {
+ "message": "پاس ورڈ سے محفوظ"
+ },
+ "notSavedYet": {
+ "message": "ابھی محفوظ نہیں ہوئی"
+ },
+ "fileAccessOffShort": {
+ "message": "مقامی فائل رسائی بند ہے"
+ },
+ "noFoldersYet": {
+ "message": "ابھی کوئی فولڈر نہیں"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 فولڈر کو دوبارہ جوڑنا ہے"
+ },
+ "statusOneFolder": {
+ "message": "$1 فولڈر · اپنی جگہ محفوظ کرتا ہے"
+ },
+ "statusFolders": {
+ "message": "$1 فولڈرز · اپنی جگہ محفوظ کرتے ہیں"
+ },
+ "renewNotOffered": {
+ "message": "Chrome نے اسے بحال کرنے کی پیشکش نہیں کی"
+ },
+ "renewTryAfterRestart": {
+ "message": "Chrome دوبارہ چلا کر پھر کوشش کریں"
+ },
+ "fetchingLatest": {
+ "message": "تازہ ترین Bento لایا جا رہا ہے…"
+ },
+ "created": {
+ "message": "$1 بنا دی گئی"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 پڑھی تو جا سکتی ہے مگر ابھی کھولی نہیں جا سکتی — Chrome کسی ایکسٹینشن کو نہیں بتاتا کہ فولڈر ڈسک پر کہاں ہے۔ <b>سب دیکھیں</b> انہیں ایک ہی کلک میں ڈھونڈ لیتا ہے۔"
+ },
+ "andMore": {
+ "message": " اور $1 مزید"
+ },
+ "agoJustNow": {
+ "message": "ابھی ابھی"
+ },
+ "agoMinutes": {
+ "message": "$1 منٹ پہلے"
+ },
+ "agoHour": {
+ "message": "$1 گھنٹہ پہلے"
+ },
+ "agoHours": {
+ "message": "$1 گھنٹے پہلے"
+ },
+ "agoDay": {
+ "message": "$1 دن پہلے"
+ },
+ "agoDays": {
+ "message": "$1 دن پہلے"
+ },
+ "searchScope": {
+ "message": "تلاش عنوانات، فائل کے ناموں، فولڈرز اور دستاویزات کے اندر کے الفاظ کو دیکھتی ہے۔"
+ },
+ "folderEmpty": {
+ "message": "اِس فولڈر میں ابھی کچھ نہیں"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ نئی دستاویز</b> یہاں ایک نئی رکھ دیتی ہے۔"
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray کو ابھی معلوم نہیں کہ $1 ڈسک پر کہاں ہے۔ ”میرے فولڈرز ڈھونڈیں“ استعمال کریں، یا اس کی کوئی دستاویز Finder سے ایک بار کھولیں۔"
+ },
+ "cardRenamedTip": {
+ "message": "$1 دوسرے نام والی ایک Bento دستاویز ہے۔ یہ یہیں سے کھلتی ہے، مگر محفوظ کرتے وقت منزل پوچھی جائے گی — اپنی جگہ محفوظ کرنا صرف اُن فائلوں کو پہچانتا ہے جو ‎.bento.html پر ختم ہوں۔"
+ },
+ "badgeRenamed": {
+ "message": "‎.bento.html کے بجائے ‎.html نام ہے — یہ یہیں سے کھلتی ہے، مگر محفوظ کرتے وقت منزل پوچھی جائے گی۔"
+ },
+ "menuOpen": {
+ "message": "کھولیں"
+ },
+ "menuDuplicate": {
+ "message": "نقل بنائیں"
+ },
+ "menuRename": {
+ "message": "نام بدلیں…"
+ },
+ "menuCopyPath": {
+ "message": "راستہ نقل کریں"
+ },
+ "duplicatedAs": {
+ "message": "$1 کے نام سے نقل بنی"
+ },
+ "renamePrompt": {
+ "message": "دستاویز کا نام بدلیں"
+ },
+ "renamedTo": {
+ "message": "نام بدل کر $1 کر دیا گیا"
+ },
+ "pathCopied": {
+ "message": "راستہ نقل ہو گیا"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — ابھی نہیں کھولا گیا"
+ },
+ "setupTitle": {
+ "message": "دو کام اور آپ تیار"
+ },
+ "setupLead": {
+ "message": "اِس کے بعد، ڈبل کلک سے کھولی گئی دستاویز میں ⌘S سیدھا اُسی فائل میں لکھتا ہے — منزل کبھی نہیں پوچھی جائے گی۔"
+ },
+ "chooseFolder": {
+ "message": "فولڈر منتخب کریں…"
+ },
+ "setupStep1": {
+ "message": "وہ فولڈر منتخب کریں جس میں آپ کی دستاویزات رہتی ہیں"
+ },
+ "setupStep1Note": {
+ "message": "عام طور پر ایک بڑا فولڈر کافی ہے — اُس کے اندر کی ہر چیز اِس میں آ جاتی ہے۔"
+ },
+ "setupStep2": {
+ "message": "مقامی فائل رسائی آن کریں"
+ },
+ "setupStep2Note": {
+ "message": "<code>chrome://extensions</code> ← Bento Tray ← <b>فائل URLs تک رسائی کی اجازت دیں</b>۔ Chrome کسی ایکسٹینشن کو یہ خود آن کرنے نہیں دیتا۔"
+ },
+ "setupUpgradeNote": {
+ "message": "<b>اپ گریڈ کیا اور سوچا کہ آپ کے فولڈرز یہیں ہوں گے؟</b> اَن پیکڈ ایکسٹینشن اپنے فولڈر کے راستے سے پہچانی جاتی ہے، اِس لیے کسی دوسرے فولڈر سے لوڈ کی گئی نئی نقل ایک الگ ایکسٹینشن ہے۔ آپ کے فولڈرز اب بھی پرانی والی سے جڑے ہیں۔ اِس کے بجائے اصل فولڈر کی فائلیں بدلیں اور <code>chrome://extensions</code> میں <b>دوبارہ لوڈ کریں</b> دبائیں۔"
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>مقامی فائل رسائی بند ہے</b> — جب تک یہ آن نہ ہو، کچھ بھی اپنی جگہ محفوظ نہیں ہوگا۔ <code>chrome://extensions</code> میں <b>فائل URLs تک رسائی کی اجازت دیں</b> آن کریں۔"
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 فولڈر کو دوبارہ جوڑنا ہے۔</b> <b>ترتیبات</b> میں اسے دوبارہ جوڑیں اور <b>ہر بار اجازت دیں</b> منتخب کریں — یہی واحد اختیار ہے جو قائم رہتا ہے۔"
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> فہرست میں دکھایا تو جا سکتا ہے مگر ابھی کھولا نہیں جا سکتا — Chrome کسی ایکسٹینشن کو کبھی نہیں بتاتا کہ فولڈر ڈسک پر کہاں ہے۔"
+ },
+ "findFolders": {
+ "message": "میرے فولڈرز ڈھونڈیں"
+ },
+ "looking": {
+ "message": "تلاش جاری ہے…"
+ },
+ "findDeclined": {
+ "message": "<b>کوئی بات نہیں۔</b> اِس کے بجائے $1 کی کوئی دستاویز Finder سے ایک بار کھول لیں — یہ صفحہ بھانپ لے گا۔"
+ },
+ "foundFolder": {
+ "message": "$1 فولڈر ملا"
+ },
+ "foundFolders": {
+ "message": "$1 فولڈرز ملے"
+ },
+ "foundNothing": {
+ "message": "تاریخ میں ابھی کچھ نہیں — Finder سے ایک دستاویز کھولیں"
+ },
+ "setFoldersSub": {
+ "message": "اِن میں رکھی دستاویزات منزل پوچھے بغیر سیدھا اُسی فائل میں محفوظ ہوتی ہیں۔ ایک فولڈر اُس کے اندر کی ہر چیز کو سمیٹ لیتا ہے۔"
+ },
+ "noneYet": {
+ "message": "ابھی کوئی نہیں۔"
+ },
+ "savesInPlace": {
+ "message": "اپنی جگہ محفوظ کرتا ہے"
+ },
+ "needsReconnecting": {
+ "message": "دوبارہ جوڑنا ہے"
+ },
+ "reconnectTip": {
+ "message": "Chrome اِس فولڈر کو بحال کرنے کی اجازت مانگے گا۔ ”اجازت نہ دیں“ اسے چھوڑ دیتا ہے، اور اُس کے بعد Chrome دوبارہ پوچھنے سے پہلے کم از کم ایک بار دوبارہ چلنے کا انتظار کرتا ہے۔"
+ },
+ "remove": {
+ "message": "ہٹائیں"
+ },
+ "removeTip": {
+ "message": "رسائی واپس لے لیتا ہے۔ Chrome اجازت یاد رکھ سکتا ہے، اِس لیے فولڈر دوبارہ شامل کرنے پر شاید کچھ نہ پوچھا جائے۔"
+ },
+ "setAccessTitle": {
+ "message": "مقامی فائل رسائی"
+ },
+ "setAccessSub": {
+ "message": "Chrome کسی ایکسٹینشن کو یہ خود آن کرنے نہیں دیتا، اور اِس کے بغیر کچھ بھی کام نہیں کرتا۔"
+ },
+ "stateOn": {
+ "message": "آن"
+ },
+ "stateOff": {
+ "message": "بند"
+ },
+ "stateUnknown": {
+ "message": "نامعلوم"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray ڈسک سے کھولے گئے صفحات پڑھ سکتا ہے۔"
+ },
+ "accessOffNote": {
+ "message": "chrome://extensions کھولیں، Bento Tray تلاش کریں، ”فائل URLs تک رسائی کی اجازت دیں“ آن کریں۔"
+ },
+ "accessUnknownNote": {
+ "message": "یہ براؤزر اِس کی اطلاع نہیں دیتا۔ اگر محفوظ کرتے وقت اب بھی پوچھا جائے تو chrome://extensions میں دیکھیں۔"
+ },
+ "setVersionTitle": {
+ "message": "ورژن"
+ },
+ "setVersionUnpacked": {
+ "message": "یہ نقل اَن پیکڈ لوڈ کی گئی تھی، اِس لیے Chrome اسے کبھی اپ ڈیٹ نہیں کرے گا۔"
+ },
+ "setVersionStore": {
+ "message": "اسٹور سے نصب کی گئی، اِس لیے یہ خود اپ ڈیٹ ہوتی ہے۔"
+ },
+ "versionAvailable": {
+ "message": "$1 دستیاب ہے"
+ },
+ "versionUpToDate": {
+ "message": "آخری جانچ کے مطابق تازہ ترین"
+ },
+ "versionManaged": {
+ "message": "براؤزر اسے تازہ رکھتا ہے"
+ },
+ "getIt": {
+ "message": "حاصل کریں"
+ },
+ "checkNow": {
+ "message": "ابھی جانچیں"
+ },
+ "autoCheckPref": {
+ "message": "<b>براؤزر شروع ہونے پر نیا ورژن جانچیں۔</b><br>ایک ساکن فائل کے لیے bento.page کو ایک درخواست۔ یہ نہ کوئی شناخت کنندہ بھیجتا ہے، نہ ورژن نمبر، اور نہ آپ کی دستاویزات کے بارے میں کچھ — موازنہ یہیں ہوتا ہے۔ اسے بند کر دیں تو کبھی کوئی درخواست نہیں جائے گی؛ <b>ابھی جانچیں</b> پھر بھی کام کرتا ہے۔"
+ },
+ "expectedSha": {
+ "message": "zip کا متوقع SHA-256: $1"
+ },
+ "setReachTitle": {
+ "message": "یہ کہاں تک پہنچ سکتا ہے"
+ },
+ "setReachSub": {
+ "message": "صرف اوپر والے فولڈرز، اور صرف وہی فائل جس سے کوئی صفحہ حقیقتاً کھولا گیا تھا۔ کچھ اپ لوڈ نہیں ہوتا اور کہیں اور کچھ نہیں پڑھا جاتا۔"
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 دستیاب ہے۔</b> یہ نقل اَن پیکڈ لوڈ کی گئی تھی، اِس لیے Chrome اسے کبھی اپ ڈیٹ نہیں کرے گا۔"
+ },
+ "updateStep1": {
+ "message": "اسے GitHub سے ڈاؤن لوڈ کریں"
+ },
+ "updateStep2": {
+ "message": "فائلیں <b>اُسی فولڈر میں</b> بدلیں <b>جس سے آپ نے اسے لوڈ کیا تھا</b> — وہی فولڈر، ورنہ Chrome اسے الگ ایکسٹینشن سمجھے گا اور اجازت یافتہ فولڈرز ساتھ نہیں آئیں گے"
+ },
+ "updateStep3": {
+ "message": "<code>chrome://extensions</code> کھولیں اور Bento Tray پر <b>دوبارہ لوڈ کریں</b> دبائیں"
+ },
+ "fetchingApp": {
+ "message": "$1 لایا جا رہا ہے…"
+ },
+ "createdIn": {
+ "message": "$3 میں $1 ($2) بنا دی گئی"
+ },
+ "intoFolder": {
+ "message": "$1 میں"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray کیا کرتا ہے"
+ },
+ "helpWhatSub": {
+ "message": "Bento دستاویز ایک ہی HTML فائل ہے جو اپنا مدیر ساتھ لیے چلتی ہے۔ سیدھا ڈسک سے کھولنے پر براؤزر اسے خود میں واپس لکھنے نہیں دیتا — اِس لیے ہر بار محفوظ کرنے پر پوچھا جاتا ہے کہ کہاں رکھیں۔ Bento Tray وہی سوال ختم کر دیتا ہے۔"
+ },
+ "tourSaveTitle": {
+ "message": "اپنی جگہ محفوظ کریں"
+ },
+ "tourSaveBody": {
+ "message": "⌘S بغیر کسی ڈائیلاگ کے سیدھا اُسی فائل میں لکھتا ہے جو آپ نے کھولی تھی۔ خودکار محفوظ کرنا اور اپنی جگہ ہونے والی اپ ڈیٹس بھی اِسی راستے جاتی ہیں۔"
+ },
+ "tourFindTitle": {
+ "message": "اپنی دستاویزات ڈھونڈیں"
+ },
+ "tourFindBody": {
+ "message": "آپ کے فولڈرز کی ہر Bento دستاویز، اُس کے اصل عنوان اور پہلے صفحے کی تصویر کے ساتھ۔ تلاش اُن کے اندر لکھی باتوں تک جاتی ہے۔"
+ },
+ "tourSwitchTitle": {
+ "message": "کام کرتے کرتے بدلیں"
+ },
+ "tourSwitchBody": {
+ "message": "ساتھ میں پینل کے لیے <kbd>Alt</kbd>+<kbd>B</kbd> دبائیں، یا دستاویز کے اندر دایاں کلک کریں۔"
+ },
+ "tourNewTitle": {
+ "message": "نئی بنائیں"
+ },
+ "tourNewBody": {
+ "message": "<b>+ نئی دستاویز</b> Slides، Spaces یا Dash کا موجودہ ریلیز لا کر آپ کے فولڈر میں ایک نئی دستاویز رکھ دیتی ہے۔"
+ },
+ "helpNeedsTitle": {
+ "message": "اسے آپ سے کیا چاہیے"
+ },
+ "helpNeedsSub": {
+ "message": "دو چیزیں، اور دونوں ہی اِس ایکسٹینشن کے بس کی نہیں۔"
+ },
+ "helpFolder": {
+ "message": "ایک فولڈر"
+ },
+ "helpFolderGranted": {
+ "message": "$1 کی اجازت ہے — اُن کے اندر کی دستاویزات اپنی جگہ محفوظ ہوتی ہیں"
+ },
+ "helpFolderNone": {
+ "message": "ابھی منتخب نہیں کیا گیا۔ ایک بڑا فولڈر اُس کے اندر کی ہر چیز کو سمیٹ لیتا ہے۔"
+ },
+ "helpAccessOff": {
+ "message": "بند۔ <code>chrome://extensions</code> میں <b>فائل URLs تک رسائی کی اجازت دیں</b> آن کریں — کوئی بھی ایکسٹینشن اسے خود آن نہیں کر سکتی۔"
+ },
+ "helpAccessUnknown": {
+ "message": "یہ براؤزر اِس کی اطلاع نہیں دیتا۔ اگر محفوظ کرتے وقت اب بھی پوچھا جائے تو <code>chrome://extensions</code> میں دیکھیں۔"
+ },
+ "helpAccessOn": {
+ "message": "آن — Bento Tray ڈسک سے کھولے گئے صفحات پڑھ سکتا ہے۔"
+ },
+ "helpNeverTitle": {
+ "message": "یہ کبھی کیا نہیں کرتا"
+ },
+ "helpNeverSub": {
+ "message": "یہ صرف اوپر والے فولڈرز کے اندر پڑھتا اور لکھتا ہے، اور صرف وہی فائل جس سے کوئی صفحہ حقیقتاً کھولا گیا تھا — کون سی، یہ براؤزر بتاتا ہے، اِس لیے کوئی دستاویز کسی اور کی فائل کا نام نہیں لے سکتی۔ آپ کی دستاویزات کے بارے میں کچھ بھی کہیں اپ لوڈ نہیں ہوتا، اور اِس ایکسٹینشن کے پاس انہیں اپ لوڈ کرنے کے لیے کوئی سرور ہے ہی نہیں۔"
+ },
+ "helpAboutTitle": {
+ "message": "تعارف"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · Bento منصوبے کا حصہ · MIT لائسنس یافتہ"
+ },
+ "linkSource": {
+ "message": "GitHub پر ماخذ"
+ },
+ "linkIssues": {
+ "message": "مسئلے کی اطلاع دیں"
+ },
+ "linkReleases": {
+ "message": "ریلیزز"
+ },
+ "primeMiddle": {
+ "message": "وہ جو قائم رہتا ہے"
+ },
+ "primeNote": {
+ "message": "باقی دونوں بھی کام کرتے ہیں، مگر Chrome دوبارہ پوچھتا ہے — پہلے کے لیے ہر بار دوبارہ چلنے پر، اور آخری کے لیے کچھ انتظار کے بعد۔"
+ }
+}
diff --git a/tray/webext/_locales/vi/messages.json b/tray/webext/_locales/vi/messages.json
new file mode 100644
index 00000000..1960b43d
--- /dev/null
+++ b/tray/webext/_locales/vi/messages.json
@@ -0,0 +1,413 @@
+{
+ "appDesc": {
+ "message": "Lưu tài liệu Bento trở lại chính tệp bạn đã mở, không hỏi nơi lưu."
+ },
+ "navAll": {
+ "message": "Tất cả tài liệu"
+ },
+ "navFolders": {
+ "message": "Thư mục"
+ },
+ "navHelp": {
+ "message": "Trợ giúp & giới thiệu"
+ },
+ "navSettings": {
+ "message": "Cài đặt"
+ },
+ "addFolder": {
+ "message": "+ Thêm thư mục…"
+ },
+ "searchDocs": {
+ "message": "Tìm trong tài liệu"
+ },
+ "searchDocsSlash": {
+ "message": "Tìm trong tài liệu /"
+ },
+ "sortTitle": {
+ "message": "Sắp xếp"
+ },
+ "sortRecent": {
+ "message": "Sửa gần đây"
+ },
+ "sortName": {
+ "message": "Tên"
+ },
+ "sortFolder": {
+ "message": "Thư mục"
+ },
+ "newDocument": {
+ "message": "+ Tài liệu mới"
+ },
+ "browseAll": {
+ "message": "Xem tất cả"
+ },
+ "reconnectFolders": {
+ "message": "Kết nối lại thư mục"
+ },
+ "primeIntro": {
+ "message": "Chrome sắp hỏi. Hãy chọn lựa chọn ở giữa:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — một thư mục cần được kết nối lại"
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray cần được kết nối lại"
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome đã thu hồi quyền với một thư mục. Cho đến khi được khôi phục, mỗi lần lưu sẽ hỏi bạn đặt tệp ở đâu."
+ },
+ "reconnect": {
+ "message": "Kết nối lại"
+ },
+ "ctxOpenPanel": {
+ "message": "Mở bảng Bento Tray"
+ },
+ "panelEmpty": {
+ "message": "Chưa có tài liệu Bento nào trong thư mục của bạn."
+ },
+ "noMatches": {
+ "message": "Không có gì khớp với “$1”"
+ },
+ "rowUnplacedTip": {
+ "message": "Mở một tài liệu trong $1 một lần từ Finder, rồi mọi thứ trong thư mục đó đều mở được từ đây."
+ },
+ "encrypted": {
+ "message": "Được bảo vệ bằng mật khẩu"
+ },
+ "notSavedYet": {
+ "message": "Chưa lưu"
+ },
+ "fileAccessOffShort": {
+ "message": "Quyền truy cập tệp cục bộ đang tắt"
+ },
+ "noFoldersYet": {
+ "message": "Chưa có thư mục nào"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 thư mục cần được kết nối lại"
+ },
+ "statusOneFolder": {
+ "message": "$1 thư mục · lưu tại chỗ"
+ },
+ "statusFolders": {
+ "message": "$1 thư mục · lưu tại chỗ"
+ },
+ "renewNotOffered": {
+ "message": "Chrome không đề nghị khôi phục nó"
+ },
+ "renewTryAfterRestart": {
+ "message": "Thử lại sau khi khởi động lại Chrome"
+ },
+ "fetchingLatest": {
+ "message": "Đang tải Bento mới nhất…"
+ },
+ "created": {
+ "message": "Đã tạo $1"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 đọc được nhưng chưa mở được — Chrome không cho tiện ích biết thư mục nằm ở đâu trên ổ đĩa. <b>Xem tất cả</b> tìm ra chúng chỉ với một cú nhấp."
+ },
+ "andMore": {
+ "message": " và $1 mục nữa"
+ },
+ "agoJustNow": {
+ "message": "vừa xong"
+ },
+ "agoMinutes": {
+ "message": "$1 phút trước"
+ },
+ "agoHour": {
+ "message": "$1 giờ trước"
+ },
+ "agoHours": {
+ "message": "$1 giờ trước"
+ },
+ "agoDay": {
+ "message": "$1 ngày trước"
+ },
+ "agoDays": {
+ "message": "$1 ngày trước"
+ },
+ "searchScope": {
+ "message": "Tìm kiếm xét tiêu đề, tên tệp, thư mục và cả chữ bên trong tài liệu."
+ },
+ "folderEmpty": {
+ "message": "Chưa có gì trong thư mục này"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ Tài liệu mới</b> sẽ đặt một tài liệu mới vào đây."
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray chưa biết $1 nằm ở đâu trên ổ đĩa. Hãy dùng “Tìm thư mục của tôi”, hoặc mở một tài liệu trong đó từ Finder một lần."
+ },
+ "cardRenamedTip": {
+ "message": "$1 là một tài liệu Bento mang tên khác. Nó mở được từ đây, nhưng khi lưu sẽ hỏi nơi lưu — lưu tại chỗ chỉ nhận các tệp kết thúc bằng .bento.html."
+ },
+ "badgeRenamed": {
+ "message": "Đặt tên .html thay vì .bento.html — mở được từ đây, nhưng khi lưu sẽ hỏi nơi lưu."
+ },
+ "menuOpen": {
+ "message": "Mở"
+ },
+ "menuDuplicate": {
+ "message": "Nhân bản"
+ },
+ "menuRename": {
+ "message": "Đổi tên…"
+ },
+ "menuCopyPath": {
+ "message": "Sao chép đường dẫn"
+ },
+ "duplicatedAs": {
+ "message": "Đã nhân bản thành $1"
+ },
+ "renamePrompt": {
+ "message": "Đổi tên tài liệu"
+ },
+ "renamedTo": {
+ "message": "Đã đổi tên thành $1"
+ },
+ "pathCopied": {
+ "message": "Đã sao chép đường dẫn"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — chưa mở lần nào"
+ },
+ "setupTitle": {
+ "message": "Hai việc là xong"
+ },
+ "setupLead": {
+ "message": "Sau đó, ⌘S trong tài liệu bạn mở bằng cách nhấp đúp sẽ ghi thẳng trở lại tệp — không bao giờ hỏi nơi lưu nữa."
+ },
+ "chooseFolder": {
+ "message": "Chọn thư mục…"
+ },
+ "setupStep1": {
+ "message": "Chọn thư mục chứa tài liệu của bạn"
+ },
+ "setupStep1Note": {
+ "message": "Một thư mục rộng thường là đủ — nó bao trùm mọi thứ bên trong."
+ },
+ "setupStep2": {
+ "message": "Bật quyền truy cập tệp cục bộ"
+ },
+ "setupStep2Note": {
+ "message": "Trong <code>chrome://extensions</code> → Bento Tray → <b>Cho phép truy cập URL tệp</b>. Chrome không cho tiện ích tự bật mục này."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>Vừa nâng cấp và tưởng thư mục của bạn vẫn ở đây?</b> Một tiện ích chưa đóng gói được nhận diện bằng đường dẫn thư mục, nên bản sao mới nạp từ thư mục khác là một tiện ích khác. Các thư mục của bạn vẫn thuộc về bản cũ. Thay vào đó, hãy thay các tệp trong thư mục ban đầu rồi nhấn <b>Tải lại</b> trong <code>chrome://extensions</code>."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>Quyền truy cập tệp cục bộ đang tắt</b> — không gì lưu tại chỗ được cho đến khi bật. Hãy bật <b>Cho phép truy cập URL tệp</b> trong <code>chrome://extensions</code>."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 thư mục cần được kết nối lại.</b> Kết nối lại trong <b>Cài đặt</b>, và chọn <b>Cho phép mỗi lần truy cập</b> — lựa chọn duy nhất giữ được lâu dài."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> liệt kê được nhưng chưa mở được — Chrome không bao giờ cho tiện ích biết thư mục nằm ở đâu trên ổ đĩa."
+ },
+ "findFolders": {
+ "message": "Tìm thư mục của tôi"
+ },
+ "looking": {
+ "message": "Đang tìm…"
+ },
+ "findDeclined": {
+ "message": "<b>Không sao.</b> Thay vào đó hãy mở một tài liệu trong $1 từ Finder một lần — trang này sẽ nhận ra."
+ },
+ "foundFolder": {
+ "message": "Đã tìm thấy $1 thư mục"
+ },
+ "foundFolders": {
+ "message": "Đã tìm thấy $1 thư mục"
+ },
+ "foundNothing": {
+ "message": "Lịch sử chưa có gì — hãy mở một tài liệu từ Finder"
+ },
+ "setFoldersSub": {
+ "message": "Tài liệu trong các thư mục này lưu thẳng trở lại tệp, không hỏi nơi lưu. Một thư mục bao trùm mọi thứ bên trong."
+ },
+ "noneYet": {
+ "message": "Chưa có."
+ },
+ "savesInPlace": {
+ "message": "lưu tại chỗ"
+ },
+ "needsReconnecting": {
+ "message": "cần được kết nối lại"
+ },
+ "reconnectTip": {
+ "message": "Chrome sẽ hỏi để khôi phục thư mục này. “Không cho phép” sẽ bỏ nó, và sau đó Chrome đợi ít nhất một lần khởi động lại trước khi hỏi tiếp."
+ },
+ "remove": {
+ "message": "Xóa"
+ },
+ "removeTip": {
+ "message": "Thu hồi quyền truy cập. Chrome vẫn có thể nhớ quyền đó, nên khi thêm lại thư mục có thể sẽ không hỏi nữa."
+ },
+ "setAccessTitle": {
+ "message": "Quyền truy cập tệp cục bộ"
+ },
+ "setAccessSub": {
+ "message": "Chrome không cho tiện ích tự bật mục này, và không có nó thì không gì hoạt động."
+ },
+ "stateOn": {
+ "message": "Bật"
+ },
+ "stateOff": {
+ "message": "Tắt"
+ },
+ "stateUnknown": {
+ "message": "Không rõ"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray có thể đọc các trang bạn mở từ ổ đĩa."
+ },
+ "accessOffNote": {
+ "message": "Mở chrome://extensions, tìm Bento Tray, bật “Cho phép truy cập URL tệp”."
+ },
+ "accessUnknownNote": {
+ "message": "Trình duyệt này không báo trạng thái. Nếu lưu vẫn hỏi, hãy kiểm tra trong chrome://extensions."
+ },
+ "setVersionTitle": {
+ "message": "Phiên bản"
+ },
+ "setVersionUnpacked": {
+ "message": "Bản sao này được nạp ở dạng chưa đóng gói, nên Chrome sẽ không bao giờ cập nhật nó."
+ },
+ "setVersionStore": {
+ "message": "Cài từ cửa hàng, nên nó tự cập nhật."
+ },
+ "versionAvailable": {
+ "message": "Đã có $1"
+ },
+ "versionUpToDate": {
+ "message": "mới nhất tính đến lần kiểm tra gần nhất"
+ },
+ "versionManaged": {
+ "message": "được trình duyệt giữ ở bản mới"
+ },
+ "getIt": {
+ "message": "Tải về"
+ },
+ "checkNow": {
+ "message": "Kiểm tra ngay"
+ },
+ "autoCheckPref": {
+ "message": "<b>Kiểm tra phiên bản mới khi trình duyệt khởi động.</b><br>Một yêu cầu tới bento.page để lấy một tệp tĩnh. Nó không gửi mã định danh, số phiên bản hay bất cứ gì về tài liệu của bạn — việc so sánh diễn ra ngay tại đây. Tắt đi thì không bao giờ có yêu cầu nào; <b>Kiểm tra ngay</b> vẫn hoạt động."
+ },
+ "expectedSha": {
+ "message": "SHA-256 mong đợi của tệp zip: $1"
+ },
+ "setReachTitle": {
+ "message": "Phạm vi truy cập"
+ },
+ "setReachSub": {
+ "message": "Chỉ các thư mục ở trên, và chỉ đúng tệp mà một trang thực sự được mở từ đó. Không gì được tải lên và không gì được đọc ở nơi khác."
+ },
+ "updateAvailable": {
+ "message": "<b>Đã có Bento Tray $1.</b> Bản sao này được nạp ở dạng chưa đóng gói, nên Chrome sẽ không bao giờ cập nhật nó."
+ },
+ "updateStep1": {
+ "message": "Tải về từ GitHub"
+ },
+ "updateStep2": {
+ "message": "Thay các tệp <b>trong chính thư mục bạn đã nạp nó</b> — đúng thư mục đó, nếu không Chrome coi đây là tiện ích khác và các thư mục đã cấp quyền sẽ không đi theo"
+ },
+ "updateStep3": {
+ "message": "Mở <code>chrome://extensions</code> và nhấn <b>Tải lại</b> ở Bento Tray"
+ },
+ "fetchingApp": {
+ "message": "Đang tải $1…"
+ },
+ "createdIn": {
+ "message": "Đã tạo $1 ($2) trong $3"
+ },
+ "intoFolder": {
+ "message": "vào $1"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray làm gì"
+ },
+ "helpWhatSub": {
+ "message": "Tài liệu Bento là một tệp HTML duy nhất mang theo trình soạn thảo của chính nó. Mở thẳng từ ổ đĩa, trình duyệt không cho nó ghi ngược lại chính mình — nên mỗi lần lưu lại hỏi bạn đặt tệp ở đâu. Bento Tray xóa bỏ câu hỏi đó."
+ },
+ "tourSaveTitle": {
+ "message": "Lưu tại chỗ"
+ },
+ "tourSaveBody": {
+ "message": "⌘S ghi thẳng trở lại tệp bạn đã mở, không hộp thoại. Tự động lưu và cập nhật tại chỗ cũng đi cùng đường đó."
+ },
+ "tourFindTitle": {
+ "message": "Tìm tài liệu của bạn"
+ },
+ "tourFindBody": {
+ "message": "Mọi tài liệu Bento trong thư mục của bạn, kèm tiêu đề thật và ảnh trang đầu. Tìm kiếm bao gồm cả nội dung viết bên trong."
+ },
+ "tourSwitchTitle": {
+ "message": "Chuyển đổi khi đang làm việc"
+ },
+ "tourSwitchBody": {
+ "message": "Nhấn <kbd>Alt</kbd>+<kbd>B</kbd>, hoặc nhấp chuột phải trong tài liệu, để mở bảng bên cạnh."
+ },
+ "tourNewTitle": {
+ "message": "Tạo tài liệu mới"
+ },
+ "tourNewBody": {
+ "message": "<b>+ Tài liệu mới</b> tải bản phát hành hiện tại của Slides, Spaces hoặc Dash và đặt một tài liệu mới vào thư mục của bạn."
+ },
+ "helpNeedsTitle": {
+ "message": "Nó cần gì ở bạn"
+ },
+ "helpNeedsSub": {
+ "message": "Hai việc, cả hai đều ngoài khả năng tự thu xếp của tiện ích này."
+ },
+ "helpFolder": {
+ "message": "Một thư mục"
+ },
+ "helpFolderGranted": {
+ "message": "đã cấp $1 — tài liệu bên trong lưu tại chỗ"
+ },
+ "helpFolderNone": {
+ "message": "Chưa chọn. Một thư mục rộng bao trùm mọi thứ bên trong."
+ },
+ "helpAccessOff": {
+ "message": "Tắt. Hãy bật <b>Cho phép truy cập URL tệp</b> trong <code>chrome://extensions</code> — không tiện ích nào tự bật được mục này."
+ },
+ "helpAccessUnknown": {
+ "message": "Trình duyệt này không báo trạng thái. Nếu lưu vẫn hỏi, hãy kiểm tra trong <code>chrome://extensions</code>."
+ },
+ "helpAccessOn": {
+ "message": "Bật — Bento Tray có thể đọc các trang bạn mở từ ổ đĩa."
+ },
+ "helpNeverTitle": {
+ "message": "Những gì nó không bao giờ làm"
+ },
+ "helpNeverSub": {
+ "message": "Nó chỉ đọc và ghi bên trong các thư mục ở trên, và chỉ đúng tệp mà một trang thực sự được mở từ đó — trình duyệt cho biết là tệp nào, nên một tài liệu không thể chỉ định tệp của người khác. Không gì về tài liệu của bạn được tải lên đâu cả, và tiện ích cũng chẳng có máy chủ nào để tải lên."
+ },
+ "helpAboutTitle": {
+ "message": "Giới thiệu"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · một phần của dự án Bento · giấy phép MIT"
+ },
+ "linkSource": {
+ "message": "Mã nguồn trên GitHub"
+ },
+ "linkIssues": {
+ "message": "Báo lỗi"
+ },
+ "linkReleases": {
+ "message": "Bản phát hành"
+ },
+ "primeMiddle": {
+ "message": "lựa chọn giữ được lâu dài"
+ },
+ "primeNote": {
+ "message": "Hai lựa chọn kia cũng dùng được, nhưng Chrome sẽ hỏi lại — lựa chọn đầu thì mỗi lần khởi động lại, lựa chọn cuối thì sau một thời gian chờ."
+ }
+}
diff --git a/tray/webext/_locales/zh_CN/messages.json b/tray/webext/_locales/zh_CN/messages.json
new file mode 100644
index 00000000..7fba6acf
--- /dev/null
+++ b/tray/webext/_locales/zh_CN/messages.json
@@ -0,0 +1,446 @@
+{
+ "appDesc": {
+ "message": "将 Bento 文档直接保存回你打开的文件,无需选择保存位置。",
+ "description": "Chrome Web Store listing description. 132 characters maximum — the store truncates."
+ },
+ "navAll": {
+ "message": "所有文档"
+ },
+ "navFolders": {
+ "message": "文件夹"
+ },
+ "navHelp": {
+ "message": "帮助与关于"
+ },
+ "navSettings": {
+ "message": "设置"
+ },
+ "addFolder": {
+ "message": "+ 添加文件夹…"
+ },
+ "searchDocs": {
+ "message": "搜索文档"
+ },
+ "searchDocsSlash": {
+ "message": "搜索文档 /"
+ },
+ "sortTitle": {
+ "message": "排序"
+ },
+ "sortRecent": {
+ "message": "最近修改"
+ },
+ "sortName": {
+ "message": "名称"
+ },
+ "sortFolder": {
+ "message": "文件夹"
+ },
+ "newDocument": {
+ "message": "+ 新建文档"
+ },
+ "browseAll": {
+ "message": "查看全部"
+ },
+ "reconnectFolders": {
+ "message": "重新连接文件夹"
+ },
+ "primeIntro": {
+ "message": "Chrome 接下来会询问。请选择中间那一项:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — 有文件夹需要重新连接",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray 需要重新连接",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome 撤销了某个文件夹的权限。在恢复之前,保存文档时会询问放在哪里。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnect": {
+ "message": "重新连接"
+ },
+ "ctxOpenPanel": {
+ "message": "打开 Bento Tray 面板"
+ },
+ "panelEmpty": {
+ "message": "你的文件夹中还没有 Bento 文档。"
+ },
+ "noMatches": {
+ "message": "没有与“$1”匹配的内容"
+ },
+ "rowUnplacedTip": {
+ "message": "从访达打开一次 $1 中的文档,之后该文件夹里的全部内容都能从这里打开。"
+ },
+ "encrypted": {
+ "message": "已用密码保护"
+ },
+ "notSavedYet": {
+ "message": "尚未保存"
+ },
+ "fileAccessOffShort": {
+ "message": "本地文件访问已关闭",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noFoldersYet": {
+ "message": "还没有文件夹"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 个文件夹需要重新连接",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "statusOneFolder": {
+ "message": "$1 个文件夹 · 原位保存"
+ },
+ "statusFolders": {
+ "message": "$1 个文件夹 · 原位保存"
+ },
+ "renewNotOffered": {
+ "message": "Chrome 没有提示恢复",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "renewTryAfterRestart": {
+ "message": "重启 Chrome 后再试一次",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "fetchingLatest": {
+ "message": "正在获取最新的 Bento…"
+ },
+ "created": {
+ "message": "已创建 $1"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 可以读取,但还无法打开——Chrome 不会告诉扩展程序文件夹在磁盘上的位置。<b>查看全部</b> 可一键找到它们。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "andMore": {
+ "message": "等 $1 个"
+ },
+ "agoJustNow": {
+ "message": "刚刚"
+ },
+ "agoMinutes": {
+ "message": "$1 分钟前"
+ },
+ "agoHour": {
+ "message": "$1 小时前"
+ },
+ "agoHours": {
+ "message": "$1 小时前"
+ },
+ "agoDay": {
+ "message": "$1 天前"
+ },
+ "agoDays": {
+ "message": "$1 天前"
+ },
+ "searchScope": {
+ "message": "搜索会查看标题、文件名、文件夹以及文档内的文字。"
+ },
+ "folderEmpty": {
+ "message": "此文件夹中还没有内容"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ 新建文档</b>会在这里放一个。"
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray 还不知道 $1 在磁盘上的位置。请使用“查找我的文件夹”,或先从访达打开该文件夹里的一个文档。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "cardRenamedTip": {
+ "message": "$1 是换了名字的 Bento 文档。可以从这里打开,但保存时会询问位置 — 原位保存只识别以 .bento.html 结尾的文件。"
+ },
+ "badgeRenamed": {
+ "message": "文件名是 .html 而不是 .bento.html — 可以从这里打开,但保存时会询问位置。"
+ },
+ "menuOpen": {
+ "message": "打开"
+ },
+ "menuDuplicate": {
+ "message": "复制"
+ },
+ "menuRename": {
+ "message": "重命名…"
+ },
+ "menuCopyPath": {
+ "message": "复制路径"
+ },
+ "duplicatedAs": {
+ "message": "已复制为 $1"
+ },
+ "renamePrompt": {
+ "message": "重命名文档"
+ },
+ "renamedTo": {
+ "message": "已重命名为 $1"
+ },
+ "pathCopied": {
+ "message": "已复制路径"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — 尚未打开"
+ },
+ "setupTitle": {
+ "message": "两步即可就绪"
+ },
+ "setupLead": {
+ "message": "完成后,在双击打开的文档中按 ⌘S 会直接写回原文件 — 再也不会询问位置。"
+ },
+ "chooseFolder": {
+ "message": "选择文件夹…"
+ },
+ "setupStep1": {
+ "message": "选择存放文档的文件夹"
+ },
+ "setupStep1Note": {
+ "message": "通常选一个大一些的文件夹就够了 — 它涵盖其中的全部内容。"
+ },
+ "setupStep2": {
+ "message": "开启本地文件访问",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupStep2Note": {
+ "message": "在 <code>chrome://extensions</code> → Bento Tray → <b>允许访问文件网址</b>。Chrome 不允许扩展程序自行开启。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>更新后没看到你的文件夹?</b>解压加载的扩展程序是按文件夹路径识别的,所以从另一个文件夹加载新副本会被当作另一个扩展程序。你的文件夹仍然授权给旧的那个。请改为替换原文件夹中的文件,然后在 <code>chrome://extensions</code> 中点击<b>重新加载</b>。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>本地文件访问已关闭</b> — 未开启前无法原位保存。请在 <code>chrome://extensions</code> 中打开<b>允许访问文件网址</b>。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 个文件夹需要重新连接。</b>请在<b>设置</b>中重新连接,并选择中间那一项 — 唯一能长期有效的选项。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> 可以列出但还打不开 — Chrome 从不告诉扩展程序文件夹在磁盘上的位置。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "findFolders": {
+ "message": "查找我的文件夹"
+ },
+ "looking": {
+ "message": "正在查找…"
+ },
+ "findDeclined": {
+ "message": "<b>没关系。</b>改为从访达打开一次 $1 中的文档 — 本页面会自动发现。"
+ },
+ "foundFolder": {
+ "message": "找到 $1 个文件夹"
+ },
+ "foundFolders": {
+ "message": "找到 $1 个文件夹"
+ },
+ "foundNothing": {
+ "message": "历史记录中还没有 — 请从访达打开一个文档"
+ },
+ "setFoldersSub": {
+ "message": "其中的文档会直接保存回原文件,不会询问位置。一个文件夹涵盖其中的全部内容。"
+ },
+ "noneYet": {
+ "message": "还没有。"
+ },
+ "savesInPlace": {
+ "message": "原位保存"
+ },
+ "needsReconnecting": {
+ "message": "需要重新连接",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnectTip": {
+ "message": "Chrome 会询问是否恢复这个文件夹。拒绝会移除它,之后 Chrome 至少要等一次重启才会再次询问。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "remove": {
+ "message": "移除"
+ },
+ "removeTip": {
+ "message": "收回访问权限。Chrome 可能仍然记着该权限,因此重新添加时可能不会再询问。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessTitle": {
+ "message": "本地文件访问",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessSub": {
+ "message": "Chrome 不允许扩展程序自行开启它,而不开启就什么都无法工作。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "stateOn": {
+ "message": "开启"
+ },
+ "stateOff": {
+ "message": "关闭"
+ },
+ "stateUnknown": {
+ "message": "未知"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray 可以读取你从磁盘打开的页面。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessOffNote": {
+ "message": "打开 chrome://extensions,找到 Bento Tray,开启“允许访问文件网址”。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessUnknownNote": {
+ "message": "此浏览器不会报告。如果保存时仍然询问位置,请在 chrome://extensions 中检查。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setVersionTitle": {
+ "message": "版本"
+ },
+ "setVersionUnpacked": {
+ "message": "这份副本是以解压方式加载的,Chrome 永远不会更新它。"
+ },
+ "setVersionStore": {
+ "message": "从商店安装,因此会自动更新。"
+ },
+ "versionAvailable": {
+ "message": "$1 可用"
+ },
+ "versionUpToDate": {
+ "message": "上次检查时为最新"
+ },
+ "versionManaged": {
+ "message": "由浏览器保持最新"
+ },
+ "getIt": {
+ "message": "获取"
+ },
+ "checkNow": {
+ "message": "立即检查"
+ },
+ "autoCheckPref": {
+ "message": "<b>浏览器启动时检查新版本。</b><br>只向 bento.page 请求一个静态文件。不发送任何标识符、版本号,也不发送与你的文档有关的内容 — 比较在本机完成。关闭后不会发出任何请求;<b>立即检查</b>仍然可用。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "expectedSha": {
+ "message": "zip 的预期 SHA-256:$1"
+ },
+ "setReachTitle": {
+ "message": "它能访问的范围",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setReachSub": {
+ "message": "只有上面的文件夹,而且只有页面实际打开的那个文件。不会上传任何内容,也不会读取其他位置。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 可用。</b>这份副本是以解压方式加载的,Chrome 永远不会更新它。"
+ },
+ "updateStep1": {
+ "message": "从 GitHub 下载"
+ },
+ "updateStep2": {
+ "message": "请在<b>你当初加载它的那个文件夹里</b>替换文件 — 必须是同一个文件夹,否则 Chrome 会当作另一个扩展程序,你已授权的文件夹不会跟着过去",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateStep3": {
+ "message": "打开 <code>chrome://extensions</code>,在 Bento Tray 上点击<b>重新加载</b>"
+ },
+ "fetchingApp": {
+ "message": "正在获取 $1…"
+ },
+ "createdIn": {
+ "message": "已在 $3 中创建 $1($2)"
+ },
+ "intoFolder": {
+ "message": "到 $1"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray 的作用"
+ },
+ "helpWhatSub": {
+ "message": "Bento 文档是一个自带编辑器的 HTML 文件。直接从磁盘打开时,浏览器不允许它写回自身 — 因此每次保存都会询问位置。Bento Tray 就是去掉这个问题的东西。"
+ },
+ "tourSaveTitle": {
+ "message": "原位保存"
+ },
+ "tourSaveBody": {
+ "message": "⌘S 无需对话框,直接写回你打开的那个文件。自动保存和更新走的是同一条路径。"
+ },
+ "tourFindTitle": {
+ "message": "找到你的文档"
+ },
+ "tourFindBody": {
+ "message": "你文件夹中的每一个 Bento 文档,带真实标题和首页缩略图。搜索也涵盖文档内的文字。"
+ },
+ "tourSwitchTitle": {
+ "message": "工作时随手切换"
+ },
+ "tourSwitchBody": {
+ "message": "按 <kbd>Alt</kbd>+<kbd>B</kbd>,或在文档中点击右键,即可在旁边打开面板。"
+ },
+ "tourNewTitle": {
+ "message": "新建一个"
+ },
+ "tourNewBody": {
+ "message": "<b>+ 新建文档</b>会获取 Slides、Spaces 或 Dash 的当前版本,并在你的文件夹中放入一个新文档。"
+ },
+ "helpNeedsTitle": {
+ "message": "它需要你做的"
+ },
+ "helpNeedsSub": {
+ "message": "两件事,都不是这个扩展程序能替你完成的。"
+ },
+ "helpFolder": {
+ "message": "一个文件夹"
+ },
+ "helpFolderGranted": {
+ "message": "已授权 $1 个 — 其中的文档会原位保存"
+ },
+ "helpFolderNone": {
+ "message": "尚未选择。选一个大一些的文件夹即可涵盖其中的全部内容。"
+ },
+ "helpAccessOff": {
+ "message": "已关闭。请在 <code>chrome://extensions</code> 中打开<b>允许访问文件网址</b> — 扩展程序无法自行开启。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessUnknown": {
+ "message": "此浏览器不会报告。如果保存时仍然询问位置,请在 <code>chrome://extensions</code> 中检查。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessOn": {
+ "message": "已开启 — Bento Tray 可以读取你从磁盘打开的页面。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverTitle": {
+ "message": "它绝不会做的",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverSub": {
+ "message": "它只在上面的文件夹内读写,而且只读写页面实际打开的那个文件 — 由浏览器告知是哪一个,所以文档无法指定别人的文件。你的文档内容不会被上传到任何地方,这个扩展程序也没有可上传的服务器。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAboutTitle": {
+ "message": "关于"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · Bento 项目的一部分 · MIT 许可"
+ },
+ "linkSource": {
+ "message": "GitHub 源码"
+ },
+ "linkIssues": {
+ "message": "报告问题"
+ },
+ "linkReleases": {
+ "message": "版本"
+ },
+ "primeMiddle": {
+ "message": "能长期有效的那个"
+ },
+ "primeNote": {
+ "message": "另外两个也能用,但 Chrome 会再次询问 — 第一个每次重启都问,最后一个会等一段时间再问。"
+ }
+}
diff --git a/tray/webext/_locales/zh_TW/messages.json b/tray/webext/_locales/zh_TW/messages.json
new file mode 100644
index 00000000..8b06a3b4
--- /dev/null
+++ b/tray/webext/_locales/zh_TW/messages.json
@@ -0,0 +1,446 @@
+{
+ "appDesc": {
+ "message": "將 Bento 文件直接儲存回你開啟的檔案,不必再選擇儲存位置。",
+ "description": "Chrome Web Store listing description. 132 characters maximum — the store truncates."
+ },
+ "navAll": {
+ "message": "所有文档"
+ },
+ "navFolders": {
+ "message": "資料夾"
+ },
+ "navHelp": {
+ "message": "說明与關於"
+ },
+ "navSettings": {
+ "message": "設定"
+ },
+ "addFolder": {
+ "message": "+ 添加資料夾…"
+ },
+ "searchDocs": {
+ "message": "搜尋文档"
+ },
+ "searchDocsSlash": {
+ "message": "搜尋文件 /"
+ },
+ "sortTitle": {
+ "message": "排序"
+ },
+ "sortRecent": {
+ "message": "最近修改"
+ },
+ "sortName": {
+ "message": "名称"
+ },
+ "sortFolder": {
+ "message": "資料夾"
+ },
+ "newDocument": {
+ "message": "+ 新增文档"
+ },
+ "browseAll": {
+ "message": "查看全部"
+ },
+ "reconnectFolders": {
+ "message": "重新連線資料夾"
+ },
+ "primeIntro": {
+ "message": "Chrome 接下來會询問。請選擇中间那一項:"
+ },
+ "actionTitle": {
+ "message": "Bento Tray"
+ },
+ "actionTitleLapsed": {
+ "message": "Bento Tray — 有資料夾需要重新連線",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedTitle": {
+ "message": "Bento Tray 需要重新連線",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "notifyLapsedBody": {
+ "message": "Chrome 撤銷了某個資料夾的權限。在恢复之前,儲存文档時會询問放在哪里。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnect": {
+ "message": "重新連線"
+ },
+ "ctxOpenPanel": {
+ "message": "打开 Bento Tray 面板"
+ },
+ "panelEmpty": {
+ "message": "你的資料夾中還沒有 Bento 文档。"
+ },
+ "noMatches": {
+ "message": "沒有与“$1”匹配的內容"
+ },
+ "rowUnplacedTip": {
+ "message": "從Finder打开一次 $1 中的文档,之後该資料夾里的全部內容都能從這里打开。"
+ },
+ "encrypted": {
+ "message": "已用密码保护"
+ },
+ "notSavedYet": {
+ "message": "尚未儲存"
+ },
+ "fileAccessOffShort": {
+ "message": "本地檔案访問已關閉",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noFoldersYet": {
+ "message": "還沒有資料夾"
+ },
+ "foldersNeedReconnect": {
+ "message": "$1 個資料夾需要重新連線",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "statusOneFolder": {
+ "message": "$1 個資料夾 · 原位儲存"
+ },
+ "statusFolders": {
+ "message": "$1 個資料夾 · 原位儲存"
+ },
+ "renewNotOffered": {
+ "message": "Chrome 沒有提示恢复",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "renewTryAfterRestart": {
+ "message": "重新啟動 Chrome 後再试一次",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "fetchingLatest": {
+ "message": "正在取得最新的 Bento…"
+ },
+ "created": {
+ "message": "已创建 $1"
+ },
+ "panelUnplaced": {
+ "message": "<b>$1</b>$2 可以讀取,但還無法開啟——Chrome 不會告訴擴充功能資料夾在磁碟上的位置。<b>查看全部</b> 可一鍵找到它們。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "andMore": {
+ "message": "等 $1 個"
+ },
+ "agoJustNow": {
+ "message": "刚刚"
+ },
+ "agoMinutes": {
+ "message": "$1 分钟前"
+ },
+ "agoHour": {
+ "message": "$1 小時前"
+ },
+ "agoHours": {
+ "message": "$1 小時前"
+ },
+ "agoDay": {
+ "message": "$1 天前"
+ },
+ "agoDays": {
+ "message": "$1 天前"
+ },
+ "searchScope": {
+ "message": "搜尋會查看標題、檔案名、資料夾以及文档内的文字。"
+ },
+ "folderEmpty": {
+ "message": "此資料夾中還沒有內容"
+ },
+ "folderEmptyHint": {
+ "message": "<b>+ 新增文档</b>會在這里放一個。"
+ },
+ "cardUnplacedTip": {
+ "message": "Bento Tray 還不知道 $1 在磁盘上的位置。請使用“查找我的資料夾”,或先從Finder打开该資料夾里的一個文档。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "cardRenamedTip": {
+ "message": "$1 是换了名字的 Bento 文档。可以從這里打开,但儲存時會询問位置 — 原位儲存只识别以 .bento.html 结尾的檔案。"
+ },
+ "badgeRenamed": {
+ "message": "檔案名是 .html 而不是 .bento.html — 可以從這里打开,但儲存時會询問位置。"
+ },
+ "menuOpen": {
+ "message": "打开"
+ },
+ "menuDuplicate": {
+ "message": "複製"
+ },
+ "menuRename": {
+ "message": "重命名…"
+ },
+ "menuCopyPath": {
+ "message": "複製路径"
+ },
+ "duplicatedAs": {
+ "message": "已複製為 $1"
+ },
+ "renamePrompt": {
+ "message": "重命名文档"
+ },
+ "renamedTo": {
+ "message": "已重命名為 $1"
+ },
+ "pathCopied": {
+ "message": "已複製路径"
+ },
+ "folderNotOpenedYet": {
+ "message": "$1 — 尚未打开"
+ },
+ "setupTitle": {
+ "message": "两步即可就绪"
+ },
+ "setupLead": {
+ "message": "完成後,在雙擊打开的文档中按 ⌘S 會直接写回原檔案 — 再也不會询問位置。"
+ },
+ "chooseFolder": {
+ "message": "選擇資料夾…"
+ },
+ "setupStep1": {
+ "message": "選擇存放文档的資料夾"
+ },
+ "setupStep1Note": {
+ "message": "通常选一個大一些的資料夾就夠了 — 它涵蓋其中的全部內容。"
+ },
+ "setupStep2": {
+ "message": "開啟本地檔案访問",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupStep2Note": {
+ "message": "在 <code>chrome://extensions</code> → Bento Tray → <b>允许访問檔案網址</b>。Chrome 不允许擴充功能自行開啟。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setupUpgradeNote": {
+ "message": "<b>更新後没看到你的資料夾?</b>解壓縮載入的擴充功能是按資料夾路径识别的,所以從另一個資料夾載入新副本會被當作另一個擴充功能。你的資料夾仍然授权给旧的那個。請改為替换原資料夾中的檔案,然後在 <code>chrome://extensions</code> 中點選<b>重新載入</b>。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeFileAccessOff": {
+ "message": "<b>本地檔案访問已關閉</b> — 未開啟前無法原位儲存。請在 <code>chrome://extensions</code> 中打开<b>允许访問檔案網址</b>。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeLapsed": {
+ "message": "<b>$1 個資料夾需要重新連線。</b>請在<b>設定</b>中重新連線,並選擇中间那一項 — 唯一能長期有效的选項。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "noticeUnplaced": {
+ "message": "<b>$1</b> 可以列出但還打不开 — Chrome 從不告诉擴充功能資料夾在磁盘上的位置。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "findFolders": {
+ "message": "查找我的資料夾"
+ },
+ "looking": {
+ "message": "正在查找…"
+ },
+ "findDeclined": {
+ "message": "<b>没关系。</b>改為從Finder打开一次 $1 中的文档 — 本頁面會自动发现。"
+ },
+ "foundFolder": {
+ "message": "找到 $1 個資料夾"
+ },
+ "foundFolders": {
+ "message": "找到 $1 個資料夾"
+ },
+ "foundNothing": {
+ "message": "瀏覽記錄中還沒有 — 請從Finder打开一個文档"
+ },
+ "setFoldersSub": {
+ "message": "其中的文档會直接儲存回原檔案,不會询問位置。一個資料夾涵蓋其中的全部內容。"
+ },
+ "noneYet": {
+ "message": "還沒有。"
+ },
+ "savesInPlace": {
+ "message": "原位儲存"
+ },
+ "needsReconnecting": {
+ "message": "需要重新連線",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "reconnectTip": {
+ "message": "Chrome 會询問是否恢复這個資料夾。拒绝會移除它,之後 Chrome 至少要等一次重新啟動才會再次询問。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "remove": {
+ "message": "移除"
+ },
+ "removeTip": {
+ "message": "收回访問權限。Chrome 可能仍然記着该權限,因此重新添加時可能不會再询問。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessTitle": {
+ "message": "本地檔案访問",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setAccessSub": {
+ "message": "Chrome 不允许擴充功能自行開啟它,而不開啟就什么都無法工作。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "stateOn": {
+ "message": "開啟"
+ },
+ "stateOff": {
+ "message": "關閉"
+ },
+ "stateUnknown": {
+ "message": "未知"
+ },
+ "accessOnNote": {
+ "message": "Bento Tray 可以讀取你從磁盘打开的頁面。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessOffNote": {
+ "message": "打开 chrome://extensions,找到 Bento Tray,開啟“允许访問檔案網址”。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "accessUnknownNote": {
+ "message": "此瀏覽器不會報告。如果儲存時仍然询問位置,請在 chrome://extensions 中檢查。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setVersionTitle": {
+ "message": "版本"
+ },
+ "setVersionUnpacked": {
+ "message": "這份副本是以解壓縮方式載入的,Chrome 永远不會更新它。"
+ },
+ "setVersionStore": {
+ "message": "從商店安装,因此會自动更新。"
+ },
+ "versionAvailable": {
+ "message": "$1 可用"
+ },
+ "versionUpToDate": {
+ "message": "上次檢查時為最新"
+ },
+ "versionManaged": {
+ "message": "由瀏覽器保持最新"
+ },
+ "getIt": {
+ "message": "取得"
+ },
+ "checkNow": {
+ "message": "立即檢查"
+ },
+ "autoCheckPref": {
+ "message": "<b>瀏覽器启动時檢查新版本。</b><br>只向 bento.page 請求一個静态檔案。不发送任何标识符、版本号,也不发送与你的文档有关的內容 — 比较在本机完成。關閉後不會发出任何請求;<b>立即檢查</b>仍然可用。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "expectedSha": {
+ "message": "zip 的预期 SHA-256:$1"
+ },
+ "setReachTitle": {
+ "message": "它能访問的范围",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "setReachSub": {
+ "message": "只有上面的資料夾,而且只有頁面實際打开的那個檔案。不會上传任何內容,也不會讀取其他位置。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateAvailable": {
+ "message": "<b>Bento Tray $1 可用。</b>這份副本是以解壓縮方式載入的,Chrome 永远不會更新它。"
+ },
+ "updateStep1": {
+ "message": "從 GitHub 下载"
+ },
+ "updateStep2": {
+ "message": "請在<b>你當初載入它的那個資料夾里</b>替换檔案 — 必须是同一個資料夾,否则 Chrome 會當作另一個擴充功能,你已授权的資料夾不會跟着過去",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "updateStep3": {
+ "message": "打开 <code>chrome://extensions</code>,在 Bento Tray 上點選<b>重新載入</b>"
+ },
+ "fetchingApp": {
+ "message": "正在取得 $1…"
+ },
+ "createdIn": {
+ "message": "已在 $3 中创建 $1($2)"
+ },
+ "intoFolder": {
+ "message": "到 $1"
+ },
+ "helpWhatTitle": {
+ "message": "Bento Tray 的作用"
+ },
+ "helpWhatSub": {
+ "message": "Bento 文档是一個自带编辑器的 HTML 檔案。直接從磁盘打开時,瀏覽器不允许它写回自身 — 因此每次儲存都會询問位置。Bento Tray 就是去掉這個問题的東西。"
+ },
+ "tourSaveTitle": {
+ "message": "原位儲存"
+ },
+ "tourSaveBody": {
+ "message": "⌘S 无需對話方塊,直接写回你打开的那個檔案。自动儲存和更新走的是同一条路径。"
+ },
+ "tourFindTitle": {
+ "message": "找到你的文档"
+ },
+ "tourFindBody": {
+ "message": "你資料夾中的每一個 Bento 文档,带真实標題和首页縮圖。搜尋也涵蓋文档内的文字。"
+ },
+ "tourSwitchTitle": {
+ "message": "工作時随手切换"
+ },
+ "tourSwitchBody": {
+ "message": "按 <kbd>Alt</kbd>+<kbd>B</kbd>,或在文档中點選右键,即可在旁边打开面板。"
+ },
+ "tourNewTitle": {
+ "message": "新增一個"
+ },
+ "tourNewBody": {
+ "message": "<b>+ 新增文档</b>會取得 Slides、Spaces 或 Dash 的當前版本,並在你的資料夾中放入一個新文档。"
+ },
+ "helpNeedsTitle": {
+ "message": "它需要你做的"
+ },
+ "helpNeedsSub": {
+ "message": "两件事,都不是這個擴充功能能替你完成的。"
+ },
+ "helpFolder": {
+ "message": "一個資料夾"
+ },
+ "helpFolderGranted": {
+ "message": "已授权 $1 個 — 其中的文档會原位儲存"
+ },
+ "helpFolderNone": {
+ "message": "尚未選擇。选一個大一些的資料夾即可涵蓋其中的全部內容。"
+ },
+ "helpAccessOff": {
+ "message": "已關閉。請在 <code>chrome://extensions</code> 中打开<b>允许访問檔案網址</b> — 擴充功能無法自行開啟。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessUnknown": {
+ "message": "此瀏覽器不會報告。如果儲存時仍然询問位置,請在 <code>chrome://extensions</code> 中檢查。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAccessOn": {
+ "message": "已開啟 — Bento Tray 可以讀取你從磁盘打开的頁面。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverTitle": {
+ "message": "它绝不會做的",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpNeverSub": {
+ "message": "它只在上面的資料夾内读写,而且只读写頁面實際打开的那個檔案 — 由瀏覽器告知是哪一個,所以文档無法指定别人的檔案。你的文档內容不會被上传到任何地方,這個擴充功能也沒有可上传的服务器。",
+ "description": "REVIEW: explains a browser permission — a mistranslation costs the user their setup."
+ },
+ "helpAboutTitle": {
+ "message": "關於"
+ },
+ "helpAboutSub": {
+ "message": "Bento Tray $1 · Bento 項目的一部分 · MIT 授權"
+ },
+ "linkSource": {
+ "message": "GitHub 源码"
+ },
+ "linkIssues": {
+ "message": "報告問题"
+ },
+ "linkReleases": {
+ "message": "版本"
+ },
+ "primeMiddle": {
+ "message": "能長期有效的那個"
+ },
+ "primeNote": {
+ "message": "另外两個也能用,但 Chrome 會再次询問 — 第一個每次重新啟動都問,最後一個會等一段時间再問。"
+ }
+}
diff --git a/tray/webext/icons/icon-128.png b/tray/webext/icons/icon-128.png
index 392830cf..b04c38eb 100644
Binary files a/tray/webext/icons/icon-128.png and b/tray/webext/icons/icon-128.png differ
diff --git a/tray/webext/icons/icon-16.png b/tray/webext/icons/icon-16.png
index 31df8ac4..5721ef8e 100644
Binary files a/tray/webext/icons/icon-16.png and b/tray/webext/icons/icon-16.png differ
diff --git a/tray/webext/icons/icon-32.png b/tray/webext/icons/icon-32.png
index 94acf924..83521b5f 100644
Binary files a/tray/webext/icons/icon-32.png and b/tray/webext/icons/icon-32.png differ
diff --git a/tray/webext/icons/icon-48.png b/tray/webext/icons/icon-48.png
index 97a04dc7..43383aa0 100644
Binary files a/tray/webext/icons/icon-48.png and b/tray/webext/icons/icon-48.png differ
diff --git a/tray/webext/icons/icon.svg b/tray/webext/icons/icon.svg
new file mode 100644
index 00000000..1a14c752
--- /dev/null
+++ b/tray/webext/icons/icon.svg
@@ -0,0 +1,21 @@
+<!--
+ bento/tray mark for the extension: the same art as tray/assets/tray-icon.svg
+ with a corner radius. That file is deliberately square and full bleed because
+ iOS applies its own squircle mask, and a radius drawn inside one seams along
+ every edge. Chrome applies no mask, so a square reads as a mistake.
+
+ THIS FILE IS THE SOURCE OF THE PNGs beside it. Chrome takes raster sizes for
+ the toolbar action icon, so those are exports of this and must be regenerated
+ rather than edited. The export command lives in tray/webext/README.md, not
+ here: it is full of command line flags, and an XML comment may not contain a
+ double hyphen. Putting it here made this file malformed, and every place the
+ mark appears rendered as a broken image.
+-->
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"
+ role="img" aria-label="Bento Tray">
+ <rect width="32" height="32" rx="7" fill="#16273E"/>
+ <rect x="4.2" y="4.2" width="23.6" height="23.6" rx="4.8" fill="#F0EBE0"/>
+ <rect x="6.800" y="6.800" width="5.855" height="18.400" rx="2.091" fill="#5E7699"/>
+ <rect x="14.327" y="6.800" width="10.873" height="8.364" rx="2.091" fill="#FF9E8A"/>
+ <rect x="14.327" y="16.836" width="10.873" height="8.364" rx="2.091" fill="#16273E"/>
+</svg>
diff --git a/tray/webext/manifest.json b/tray/webext/manifest.json
index a5a6d75c..e3307421 100644
--- a/tray/webext/manifest.json
+++ b/tray/webext/manifest.json
@@ -1,13 +1,19 @@
{
"manifest_version": 3,
- "name": "Bento Tray",
+ "name": "__MSG_appName__",
"version": "1.0.0",
- "description": "Save a Bento document back to the file you opened, without a destination prompt.",
+ "description": "__MSG_appDesc__",
"minimum_chrome_version": "116",
"permissions": [
+ "contextMenus",
+ "notifications",
+ "sidePanel",
"storage"
],
- "options_page": "src/options.html",
+ "optional_permissions": [
+ "history"
+ ],
+ "options_page": "src/home.html",
"background": {
"service_worker": "src/background.js",
"type": "module"
@@ -41,13 +47,25 @@
"128": "icons/icon-128.png"
},
"action": {
- "default_title": "Bento Tray",
- "default_popup": "src/popup.html",
+ "default_title": "Bento Tray \u2014 your documents",
"default_icon": {
"16": "icons/icon-16.png",
"32": "icons/icon-32.png",
"48": "icons/icon-48.png",
"128": "icons/icon-128.png"
}
- }
+ },
+ "side_panel": {
+ "default_path": "src/panel.html"
+ },
+ "commands": {
+ "open-panel": {
+ "suggested_key": {
+ "default": "Alt+B",
+ "mac": "Alt+B"
+ },
+ "description": "Open the Bento Tray panel beside this document"
+ }
+ },
+ "default_locale": "en"
}
diff --git a/tray/webext/src/background.js b/tray/webext/src/background.js
index d9981daf..4bc7987e 100644
--- a/tray/webext/src/background.js
+++ b/tray/webext/src/background.js
@@ -27,46 +27,33 @@
// else's deck in the granted folder and overwrite it. The path comes from
// the sender, and a payload path is ignored even if present.
-const DB = 'bento-tray'
-const STORE = 'grant'
-
-const open = () => new Promise((res, rej) => {
- const r = indexedDB.open(DB, 1)
- r.onupgradeneeded = () => r.result.createObjectStore(STORE)
- r.onsuccess = () => res(r.result)
- r.onerror = () => rej(r.error)
-})
-
-async function readGrant() {
- const d = await open()
- return new Promise((res, rej) => {
- const t = d.transaction(STORE, 'readonly')
- const q = t.objectStore(STORE).get('dir')
- q.onsuccess = () => res(q.result ?? null)
- q.onerror = () => rej(q.error)
- })
-}
+// The ONLY import here. status.js owns what the UI is told, and the badge is
+// UI — duplicating the "is anything lapsed?" rule would let the icon and the
+// popup disagree about the same folders.
+import { setLapsedBadge, notifyIfLapsed, openReconnectUi, getGrants } from './status.js'
+import { checkForUpdate } from './update.js'
+import { learnPrefix } from './db.js'
+import { t } from './i18n.js'
+import { pathFromSender, locateIn } from './route.js'
-/**
- * The file this message is about, according to the BROWSER.
- *
- * Not according to the page: a content script's `sender.url` is stamped by
- * Chrome. Only `file:` is accepted — the bridge exists for local documents, and
- * an http page has no business claiming one.
- */
-export function pathFromSender(sender) {
- try {
- const u = new URL(sender?.url ?? '')
- if (u.protocol !== 'file:') return null
- return decodeURIComponent(u.pathname)
- } catch {
- return null
- }
-}
+// Re-exported: these moved to route.js so the PAGES can place a path too,
+// but they are still part of this module's tested surface.
+export { pathFromSender, locateIn }
+
+/** Refresh the badge, and tell the user once per session if a grant lapsed. */
+const reportLapsed = async () => notifyIfLapsed(await setLapsedBadge())
+
+/** The grants, read through the shared store. */
+const readGrants = getGrants
/** Every file of this name in the granted tree. Depth-limited: a Decks folder
* is not a filesystem, and an unbounded walk on a mistakenly-granted home
- * directory would hang the save the user is waiting on. */
+ * directory would hang the save the user is waiting on.
+ *
+ * KEPT AS A FALLBACK ONLY. `locateIn` handles every path whose grant name
+ * appears in it, which is all of them in the ordinary case; this covers what
+ * it cannot place — a symlinked route, say, where the path the browser reports
+ * does not spell the directory the handle actually points at. */
export async function findByName(dir, name, depth = 0, found = []) {
if (depth > 4 || found.length > 1) return found
for await (const [entryName, handle] of dir.entries()) {
@@ -82,39 +69,74 @@ export async function findByName(dir, name, depth = 0, found = []) {
/**
* Resolve the writable handle for a sender's own file, or say why not.
*
- * THE MATCHING PROBLEM. A page is at `/Users/…/Decks/Q3.bento.html`; a
- * `FileSystemDirectoryHandle` knows its own NAME but not its path, and no API
- * exposes one, so the two cannot be compared directly. This searches the
- * granted tree for that file name and requires EXACTLY ONE match — unambiguous
- * in the ordinary case, and when it is ambiguous the answer is to decline and
- * let the browser's own picker handle it. Declining costs a prompt; guessing
- * costs somebody's file.
+ * ACROSS EVERY GRANT. Each is tried by ROUTE (`locateIn`) rather than by
+ * search, so trying several costs a few lookups each and a grant's size stops
+ * mattering — granting a whole home directory is as cheap as granting one decks
+ * folder, which is what makes "everywhere" a reasonable thing to offer.
+ *
+ * A file reachable through two grants is normal once folders can nest
+ * (~/Documents and ~/Documents/Decks), and it is the SAME file by two routes,
+ * not an ambiguity — `isSameEntry` is the thing that can tell those apart, so
+ * it decides. Two genuinely different files can only happen if the browser
+ * reported a path that leads to both, which it cannot; if it somehow does, that
+ * is the case to decline.
+ *
+ * A LAPSED grant is reported distinctly from an absent one, because they need
+ * opposite things from the user: one click to renew, or a folder to pick. Only
+ * reported when NO grant could serve the file — with several folders, one
+ * lapsing must not mask the others.
*/
export async function resolve(sender, deps = {}) {
- const grant = deps.readGrant ?? readGrant
+ const grants = deps.readGrants ?? readGrants
const search = deps.findByName ?? findByName
+ const locate = deps.locateIn ?? locateIn
const path = pathFromSender(sender)
if (!path) return { ok: false, reason: 'not a local file' }
- const dir = await grant()
- if (!dir) return { ok: false, reason: 'no folder granted' }
- // queryPermission only — never prompt from here. A service worker has no user
- // gesture, so a request would be refused, and a save is the wrong moment to
- // discover that. The options page is where granting happens.
- const perm = await dir.queryPermission({ mode: 'readwrite' })
- if (perm !== 'granted') return { ok: false, reason: 'folder grant needs renewing' }
+ const all = await grants()
+ if (!all.length) return { ok: false, reason: 'no folder granted' }
const name = path.split('/').pop() || ''
if (!name) return { ok: false, reason: 'no file name' }
- const hits = await search(dir, name)
- if (hits.length !== 1) {
+
+ let lapsed = 0
+ const found = []
+ for (const dir of all) {
+ // queryPermission only — never prompt from here. A service worker has no
+ // user gesture, so a request would be refused, and a save is the wrong
+ // moment to discover that. The options page is where granting happens.
+ if (await dir.queryPermission({ mode: 'readwrite' }) !== 'granted') { lapsed++; continue }
+ for (const hit of await locate(dir, path)) found.push({ dir, ...hit })
+ // Only fall back to enumerating when the route found nothing in this grant.
+ if (!found.length) {
+ for (const file of await search(dir, name)) found.push({ dir, file, rel: null })
+ }
+ }
+
+ if (!found.length) {
return {
ok: false,
- reason: hits.length ? `${name} is ambiguous in the granted folder` : 'not in the granted folder',
+ reason: lapsed
+ ? 'folder grant needs renewing'
+ : 'not in the granted folder',
+ }
+ }
+ if (found.length > 1) {
+ // The same file reached twice through nested grants is fine; two different
+ // files are not, and only isSameEntry can tell them apart.
+ const [first, ...rest] = found
+ for (const other of rest) {
+ if (!(await first.file.isSameEntry(other.file))) {
+ return { ok: false, reason: `${name} is ambiguous across the granted folders` }
+ }
}
+ found.length = 1
}
+ const { dir, file } = found[0]
+ const hits = [file]
+
// The candidate shares the sender's FILE NAME. That is not the same as being
// the sender's file, and treating it as such destroys documents:
//
@@ -133,6 +155,20 @@ export async function resolve(sender, deps = {}) {
const rel = await dir.resolve(hits[0])
if (!rel || !rel.length) return { ok: false, reason: 'not inside the granted folder' }
const suffix = `/${rel.join('/')}`
+ // The subtraction that makes a document list clickable. Both halves exist
+ // only here: `path` is absolute and browser-stamped, `suffix` is the same
+ // file's route from the grant root, so what remains is where the granted
+ // folder actually lives. Nothing else in the extension can learn this — a
+ // directory handle has no path — and without it the popup can list documents
+ // but not open them.
+ //
+ // Deliberately AFTER the identity check below is set up but before it
+ // returns: only recorded on the success path, so a mismatched candidate never
+ // teaches us a wrong prefix. Failures are swallowed; a save must not break
+ // because a convenience could not be cached.
+ if (path.endsWith(suffix)) {
+ try { await learnPrefix(dir.name, path.slice(0, -suffix.length)) } catch { /* nice-to-have */ }
+ }
if (!path.endsWith(suffix)) {
return { ok: false, reason: `${name} in the granted folder is a different file` }
}
@@ -236,11 +272,121 @@ export async function write(sender, text, deps) {
// the logic above and never needs the listener.
if (typeof chrome !== 'undefined' && chrome.runtime?.onMessage) {
chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
- const run = msg?.op === 'claim' ? claim(sender)
+ // `hello` is a claim by another name: it resolves the sender against the
+ // grants, which is what teaches `db.learnPrefix` where that folder lives,
+ // and writes nothing. Opening a document is the moment to learn its folder
+ // — waiting for a save meant a fresh install listed documents it could not
+ // open.
+ const run = msg?.op === 'hello' ? claim(sender)
+ : msg?.op === 'claim' ? claim(sender)
: msg?.op === 'write' ? write(sender, msg.payload?.text ?? '')
: msg?.op === 'backup' ? backup(sender, msg.payload?.text ?? '', msg.payload?.name)
: Promise.resolve({ ok: false, reason: 'unknown op' })
- run.then(sendResponse, (e) => sendResponse({ ok: false, reason: String(e?.message || e) }))
+ run.then((r) => {
+ sendResponse(r)
+ // A lapsed grant is otherwise invisible until a save has ALREADY fallen
+ // back to a picker. Badging the toolbar icon moves that discovery onto
+ // the thing the fix hangs off, and does it whether the save succeeded or
+ // not — one folder can lapse while another still works.
+ void reportLapsed()
+ }, (e) => sendResponse({ ok: false, reason: String(e?.message || e) }))
return true // async response
})
+
+ // The worker restarts constantly; the badge has to survive that, and startup
+ // is also when a browser restart would have dropped a grant — so it is the
+ // one moment where telling the user is worth an interruption, since it is
+ // before they have tried to save anything.
+ chrome.runtime.onStartup?.addListener(() => void reportLapsed())
+ chrome.runtime.onInstalled?.addListener(() => void reportLapsed())
+
+ // Whether an unpacked install is behind. Startup only, plus a manual check in
+ // Settings: a browser session is the natural granularity, and a daily alarm
+ // would cost the `alarms` permission for a courtesy. Store installs are never
+ // asked — `checkForUpdate` returns immediately for them.
+ chrome.runtime.onStartup?.addListener(() => void checkForUpdate())
+ chrome.runtime.onInstalled?.addListener(() => void checkForUpdate())
+ void reportLapsed()
+
+ /**
+ * The toolbar icon opens the LIBRARY, not a popup.
+ *
+ * Two surfaces, two jobs. The page is for browsing and managing — folders,
+ * search, rename, settings — and wants room and a tab that stays. The panel
+ * is for switching documents while you are working in one, and wants to sit
+ * beside that document rather than vanish when you click into it.
+ *
+ * `onClicked` only fires when no `default_popup` is declared: setting one
+ * makes the click open the popup and this listener never run. So the manifest
+ * has no popup, and the panel is reached by its own gestures below.
+ *
+ * An existing tab is FOCUSED rather than duplicated. Opening the library four
+ * times should not leave four copies of it.
+ */
+ chrome.action.onClicked.addListener(async () => {
+ const url = chrome.runtime.getURL('src/home.html')
+ const [open] = await chrome.tabs.query({ url })
+ if (open) {
+ await chrome.tabs.update(open.id, { active: true })
+ await chrome.windows.update(open.windowId, { focused: true })
+ } else {
+ await chrome.tabs.create({ url })
+ }
+ })
+
+ /**
+ * The panel, from a keyboard shortcut.
+ *
+ * `sidePanel.open()` must be called SYNCHRONOUSLY inside the gesture that
+ * triggered it — Chrome 116+, which is this extension's floor exactly. An
+ * `await` before it, even a trivial one, loses the gesture and the call is
+ * refused. So nothing is read first; the panel decides what to show once it
+ * is up.
+ */
+ chrome.commands?.onCommand.addListener((command, tab) => {
+ if (command !== 'open-panel') return
+ chrome.sidePanel.open(tab?.windowId != null
+ ? { windowId: tab.windowId }
+ : { windowId: chrome.windows.WINDOW_ID_CURRENT })
+ })
+
+ // And from a right-click inside a document, which is where wanting it
+ // actually happens. Same synchronous rule.
+ /**
+ * A fresh install opens the welcome view once.
+ *
+ * `reason === 'install'` only — an UPDATE must not steal a tab, and a browser
+ * that reloads an unpacked extension fires this every time. The first
+ * question after installing is "what did I just install and what does it need
+ * from me", and the toolbar icon answers none of that until someone clicks it.
+ */
+ chrome.runtime.onInstalled.addListener(({ reason }) => {
+ if (reason !== 'install') return
+ void chrome.tabs.create({ url: `${chrome.runtime.getURL('src/home.html')}#welcome` })
+ })
+
+ chrome.runtime.onInstalled.addListener(() => {
+ chrome.contextMenus?.removeAll(() => {
+ chrome.contextMenus.create({
+ id: 'bento-tray-panel',
+ title: t('ctxOpenPanel'),
+ contexts: ['page'],
+ documentUrlPatterns: ['file:///*'],
+ })
+ })
+ })
+ chrome.contextMenus?.onClicked.addListener((info, tab) => {
+ if (info.menuItemId === 'bento-tray-panel' && tab?.windowId != null) {
+ chrome.sidePanel.open({ windowId: tab.windowId })
+ }
+ })
+
+ // The notification's only button, and clicking the notification body itself —
+ // both mean "fix it", so both lead to the same place.
+ chrome.notifications?.onButtonClicked?.addListener((id) => {
+ if (id === 'bento-tray-lapsed') void openReconnectUi()
+ })
+ chrome.notifications?.onClicked?.addListener((id) => {
+ if (id === 'bento-tray-lapsed') void openReconnectUi()
+ })
}
diff --git a/tray/webext/src/db.js b/tray/webext/src/db.js
new file mode 100644
index 00000000..6246c9c0
--- /dev/null
+++ b/tray/webext/src/db.js
@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+//
+// The one place IndexedDB is opened.
+//
+// It used to be opened in two files — the service worker and the status module
+// — with the database name, store name and key strings duplicated between them.
+// That is a split-brain waiting to happen: if they drift, the options page
+// writes grants the worker never reads, the UI looks healthy, every save
+// prompts, and nothing reports a fault. A rig had to gate the two copies
+// against each other. One module is better than a gate.
+//
+// STORES
+//
+// grant the durable, small things
+// dirs [FileSystemDirectoryHandle] every granted folder
+// dir legacy single grant, still read so an upgrade does not
+// silently drop a folder somebody already granted
+// prefixes {folderName: '/absolute/path'} — see below
+//
+// cache derived, disposable: one entry per document, holding what was read
+// out of it (title, preview) keyed by size+mtime so a changed file
+// re-reads. Nothing here is authoritative; deleting it costs a
+// re-read and nothing else.
+//
+// WHY `prefixes` EXISTS. A FileSystemDirectoryHandle knows its name and never
+// its path, so the extension cannot turn a document it can WRITE into a URL it
+// can OPEN. But when a deck is open, the browser stamps `sender.url` with the
+// absolute path, and `dir.resolve()` gives that same file's path relative to
+// the grant. Subtract one from the other and the grant's absolute prefix falls
+// out. That is `locateIn` run backwards, and it is what makes a document list
+// clickable.
+
+const DB = 'bento-tray'
+const VERSION = 2
+export const GRANT = 'grant'
+export const CACHE = 'cache'
+
+export const open = () => new Promise((res, rej) => {
+ const r = indexedDB.open(DB, VERSION)
+ r.onupgradeneeded = (ev) => {
+ const d = r.result
+ // Additive only, and version-guarded rather than existence-guarded, so the
+ // path from a v1 install is explicit rather than incidental.
+ if (!d.objectStoreNames.contains(GRANT)) d.createObjectStore(GRANT)
+ if (!d.objectStoreNames.contains(CACHE)) d.createObjectStore(CACHE)
+ void ev
+ }
+ r.onsuccess = () => res(r.result)
+ r.onerror = () => rej(r.error)
+})
+
+export const get = async (store, key) => {
+ const d = await open()
+ return new Promise((res, rej) => {
+ const q = d.transaction(store, 'readonly').objectStore(store).get(key)
+ q.onsuccess = () => res(q.result ?? null)
+ q.onerror = () => rej(q.error)
+ })
+}
+
+export const put = async (store, key, value) => {
+ const d = await open()
+ return new Promise((res, rej) => {
+ const t = d.transaction(store, 'readwrite')
+ t.objectStore(store).put(value, key)
+ t.oncomplete = res
+ t.onerror = () => rej(t.error)
+ })
+}
+
+/**
+ * Remember where a granted folder actually lives on disk.
+ *
+ * Keyed by folder NAME, which can collide — two grants both called `Decks`
+ * would share an entry. The cost of a collision is a document link pointing at
+ * a path that does not exist, so the tab opens on nothing; it can never write
+ * to the wrong file, because writing does not go through here at all. That is
+ * a tolerable ceiling for a convenience, and the alternative (keying by handle)
+ * is not expressible — handles are not valid keys and have no stable id.
+ */
+export async function learnPrefix(folderName, absolutePrefix) {
+ const all = (await get(GRANT, 'prefixes')) || {}
+ if (all[folderName] === absolutePrefix) return // the common case: no write
+ all[folderName] = absolutePrefix
+ await put(GRANT, 'prefixes', all)
+}
+
+export const prefixes = async () => (await get(GRANT, 'prefixes')) || {}
diff --git a/tray/webext/src/home.html b/tray/webext/src/home.html
new file mode 100644
index 00000000..6ed32998
--- /dev/null
+++ b/tray/webext/src/home.html
@@ -0,0 +1,179 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>bento/tray</title>
+<link rel="icon" href="../icons/icon.svg">
+<link rel="stylesheet" href="ui.css">
+<style>
+ /* Page-specific layout only. Everything shared — palette, controls, notices,
+ menus, toasts — lives in ui.css, so this page and the popup cannot drift
+ into looking like two different products, which they had. */
+
+ body { height: 100vh; display: grid; grid-template-columns: 232px 1fr }
+
+ /* ---------------------------------------------------------------- sidebar */
+ aside { border-inline-end: 1px solid var(--line); padding: 18px 12px; display: flex;
+ flex-direction: column; gap: 4px; overflow-y: auto }
+ .brand { display: flex; align-items: center; gap: 9px; padding: 0 8px 14px }
+ .brand .mark { width: 24px; height: 24px }
+ .brand b { font-size: 15px; letter-spacing: -.01em }
+ .brand b i { color: var(--peach); font-style: normal }
+
+ .navitem { display: flex; align-items: center; gap: 9px; width: 100%; text-align: start;
+ padding: 7px 9px; border: 0; border-radius: 8px; background: none; color: inherit;
+ font: inherit; cursor: pointer }
+ .navitem:hover { background: var(--hover) }
+ .navitem[aria-current="true"] { background: var(--hover); font-weight: 600 }
+ .navitem .n { margin-inline-start: auto; color: var(--dim); font-size: 12px;
+ font-variant-numeric: tabular-nums }
+ .seclabel { color: var(--dim); font-size: 11px; letter-spacing: .06em; text-transform: uppercase;
+ padding: 14px 9px 5px }
+ aside .spacer { flex: 1 }
+
+ /* ------------------------------------------------------------------- main */
+ main { display: flex; flex-direction: column; min-width: 0; height: 100vh }
+ .bar { display: flex; align-items: center; gap: 10px; padding: 16px 22px 12px }
+ .bar h1 { flex: none }
+ .search { flex: 1; max-width: 340px; position: relative }
+ .search input { width: 100%; padding-inline-start: 30px }
+ .search .mag { position: absolute; inset-inline-start: 10px; top: 50%; transform: translateY(-50%);
+ color: var(--dim); font-size: 12px; pointer-events: none }
+ .grow { flex: 1 }
+ #notice { display: grid; gap: 8px; padding: 0 22px 10px }
+ #notice:empty { padding: 0 }
+
+ .scroll { flex: 1; overflow-y: auto; padding: 6px 22px 28px }
+
+ /* ------------------------------------------------------------------ grid */
+ .grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(214px, 1fr));
+ gap: 16px; align-content: start }
+ .card { position: relative; border: 1px solid var(--line); border-radius: 12px;
+ background: var(--panel); overflow: hidden; box-shadow: var(--shadow); cursor: pointer;
+ text-align: start; padding: 0; color: inherit; font: inherit; display: flex;
+ flex-direction: column; transition: transform .13s ease, box-shadow .13s ease }
+ .card:hover { transform: translateY(-2px); box-shadow: var(--lift) }
+ /* An unopenable card must not read as a BROKEN card: the text stays full
+ strength and only the picture area is marked, so "waiting" does not look
+ like "faulty" — and neither looks like a document that simply has no
+ thumbnail yet, which is perfectly healthy. */
+ .card[disabled] { cursor: default }
+ .card[disabled]:hover { transform: none; box-shadow: var(--shadow) }
+ .card.unplaced .shot { border: 1px dashed var(--line);
+ background: repeating-linear-gradient(45deg, transparent, transparent 7px,
+ var(--hover) 7px, var(--hover) 14px) }
+ .card.unplaced .cardbody b { opacity: .75 }
+
+ .shot { aspect-ratio: 16/9; background: var(--hover); position: relative; overflow: hidden;
+ border-bottom: 1px solid var(--line) }
+ .shot iframe { width: 1280px; height: 720px; border: 0; transform-origin: 0 0;
+ position: absolute; inset-inline-start: 0; top: 0; pointer-events: none }
+ .shot .glyph { position: absolute; inset: 0; display: grid; place-items: center;
+ color: var(--dim); font-size: 26px }
+ .shot .label { position: absolute; inset: 0; display: grid; place-items: center;
+ color: var(--dim); font-size: 12px }
+
+ .cardbody { padding: 10px 12px 12px; display: flex; gap: 8px; align-items: flex-start }
+ .cardbody .txt { min-width: 0; flex: 1 }
+ .cardbody b { display: block; font-weight: 600; white-space: nowrap; overflow: hidden;
+ text-overflow: ellipsis }
+ .cardbody span { display: block; color: var(--dim); font-size: 12px; white-space: nowrap;
+ overflow: hidden; text-overflow: ellipsis }
+ .more { border: 0; background: none; color: var(--dim); cursor: pointer; font: inherit;
+ padding: 2px 5px; border-radius: 6px; line-height: 1 }
+ .more:hover { background: var(--hover); color: var(--ink) }
+
+ /* Which Bento a document is, and whether it is named like one. Both sit on
+ the picture so they never push the title around. */
+ .badges { position: absolute; top: 7px; inset-inline-end: 7px; display: flex; gap: 4px }
+ .badges span { background: var(--panel); border: 1px solid var(--line); color: var(--dim);
+ font-size: 10.5px; line-height: 1; padding: 3px 5px; border-radius: 5px;
+ letter-spacing: .02em }
+
+ /* ------------------------------------------------------- empty and set-up */
+ .empty { max-width: 52ch; color: var(--dim); padding: 20px 0 }
+ .empty h2 { color: var(--ink) }
+ .empty p { margin: 0 0 10px }
+ .steps { display: grid; gap: 10px; margin: 18px 0 0; max-width: 46ch }
+ .step { display: flex; gap: 11px; align-items: flex-start; background: var(--panel);
+ border: 1px solid var(--line); border-radius: 10px; padding: 12px 13px;
+ box-shadow: var(--shadow) }
+ .step .num { width: 21px; height: 21px; border-radius: 50%; background: var(--hover);
+ color: var(--ink); font-size: 12px; display: grid; place-items: center; flex: none;
+ font-variant-numeric: tabular-nums }
+ .step .txt { flex: 1 }
+ /* The step's TITLE, not every <b> inside it. Unscoped, this turned a bolded
+ phrase in the middle of the note into its own line and broke the sentence
+ around it. */
+ .step .txt > b { display: block; color: var(--ink) }
+ .step small { color: var(--dim); font-size: 12.5px; display: block }
+ .step small b { color: var(--ink) }
+ .step.done .num { background: var(--good); color: var(--on-good) }
+ .step .btn { margin-top: 9px }
+
+ /* ---------------------------------------------------------------- settings */
+ .panel { max-width: 44rem }
+ .panel section { margin-bottom: 26px }
+ .panel h2 { margin-bottom: 4px }
+ .panel .sub { color: var(--dim); margin: 0 0 12px; font-size: 13px }
+ .row { display: flex; align-items: center; gap: 10px; padding: 10px 13px;
+ border: 1px solid var(--line); border-radius: 10px; background: var(--panel);
+ margin-bottom: 7px }
+ .row b { flex: 0 1 auto; overflow: hidden; text-overflow: ellipsis; white-space: nowrap }
+ .row .note { color: var(--dim); font-size: 12.5px; flex: 1 }
+ .row .btn { padding: 4px 9px; font-size: 12.5px }
+
+ /* ------------------------------------------------------------------- help */
+ .tour { display: grid; gap: 12px; margin: 4px 0 8px; max-width: 46rem;
+ grid-template-columns: repeat(auto-fit, minmax(210px, 1fr)) }
+ .tour .card { padding: 14px 15px; cursor: default; display: block }
+ .tour .card:hover { transform: none; box-shadow: var(--shadow) }
+ /* The card's TITLE, not every <b> in it — exactly the mistake `.step b` made,
+ which turned a bolded phrase mid-sentence into its own line. Made twice
+ now, which is what an unscoped element selector inside a component is for. */
+ .tour .card > b { display: block; margin-bottom: 3px }
+ .tour p { margin: 0; color: var(--dim); font-size: 13px }
+ .tour kbd { background: var(--hover); border: 1px solid var(--line); border-radius: 5px;
+ padding: 1px 5px; font: inherit; font-size: 12px }
+ .links { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 4px }
+</style>
+
+<aside>
+ <div class="brand">
+ <img class="mark" src="../icons/icon.svg" alt="">
+ <b>bento<i>/</i>tray</b>
+ </div>
+
+ <button class="navitem" id="navAll" aria-current="true">
+ <span class="dot"></span> <span data-i18n="navAll"></span> <span class="n" id="nAll"></span>
+ </button>
+
+ <div class="seclabel" data-i18n="navFolders"></div>
+ <div id="folders"></div>
+
+ <button class="btn ghost" id="addFolder" data-i18n="addFolder"></button>
+
+ <div class="spacer"></div>
+ <button class="navitem" id="help"><span class="dot"></span> <span data-i18n="navHelp"></span></button>
+ <button class="navitem" id="settings"><span class="dot"></span> <span data-i18n="navSettings"></span></button>
+</aside>
+
+<main>
+ <div class="bar">
+ <h1 id="heading" data-i18n="navAll"></h1>
+ <div class="search" id="searchWrap">
+ <span class="mag">⌕</span>
+ <input id="q" type="search" data-i18n-placeholder="searchDocsSlash" autocomplete="off">
+ </div>
+ <select id="sort" data-i18n-title="sortTitle">
+ <option value="recent" data-i18n="sortRecent"></option>
+ <option value="name" data-i18n="sortName"></option>
+ <option value="folder" data-i18n="sortFolder"></option>
+ </select>
+ <span class="grow"></span>
+ <button class="btn primary" id="new" data-i18n="newDocument"></button>
+ </div>
+
+ <div id="notice"></div>
+ <div class="scroll"><div class="grid" id="grid"></div></div>
+</main>
+
+<script type="module" src="home.js"></script>
diff --git a/tray/webext/src/home.js b/tray/webext/src/home.js
new file mode 100644
index 00000000..89230635
--- /dev/null
+++ b/tray/webext/src/home.js
@@ -0,0 +1,901 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+//
+// The full page: somewhere to actually live with your documents.
+//
+// The popup answers "open the thing I just had" in 340px and dies when it loses
+// focus. Browsing is a different job — folders, search, sorting, a thumbnail big
+// enough to recognise a deck by — and it needs a page that stays open.
+//
+// Everything here reads through `library.js`, so the popup and this page cannot
+// disagree about what a document is or where it lives. The rules that matter
+// (enumeration is fine here, resolution never enumerates; the absolute path is
+// learned, not derived) live there and are explained there.
+
+import { getGrants, putGrants, status } from './status.js'
+import { listDocuments, describe, newDocument, duplicate, rename, APPS } from './library.js'
+import { prefixFor } from './route.js'
+import { learnPrefix } from './db.js'
+import { checkForUpdate, pendingUpdate, isSelfManaged, autoCheckEnabled, setAutoCheck } from './update.js'
+import { t, localize } from './i18n.js'
+
+/**
+ * Find the granted folders on disk, without sending anyone to Finder.
+ *
+ * THE PROBLEM. A `FileSystemDirectoryHandle` never exposes a path, so the
+ * extension can read and write a folder while having no idea where it is — and
+ * an absolute path is what a tab needs to open a document. Until now the only
+ * source was a document loading out of the folder and its content script
+ * reporting `sender.url`. Which works, and is a terrible first run: install the
+ * thing, open it, and every document is greyed out with instructions to go
+ * double-click something in Finder first.
+ *
+ * THE WAY OUT. Chrome already knows. If a document has ever been opened, its
+ * `file://` URL is in history, and one search yields the absolute path of every
+ * Bento document the user has. That is enough to place every folder at once.
+ *
+ * WHY IT IS OPTIONAL, AND HELD FOR SECONDS. "Read your browsing history" is a
+ * heavy permission and a fair thing to balk at on a store listing, so it is not
+ * requested at install: it is asked for by a button, at the moment it is needed,
+ * with the reason on screen — and handed straight back. The extension holds it
+ * for the length of one query.
+ *
+ * NOTHING IS TRUSTED. A history URL is a hint, not an answer. Every candidate
+ * is verified by `prefixFor`, which walks the route inside the grant and makes
+ * `dir.resolve()` agree with the path's own tail. A path that cannot be proven
+ * to be inside a granted folder teaches nothing.
+ */
+async function locateFolders() {
+ const granted = await chrome.permissions.request({ permissions: ['history'] })
+ if (!granted) return { learned: 0, declined: true }
+
+ let learned = 0
+ try {
+ const items = await chrome.history.search({
+ text: '.bento.html', maxResults: 5000, startTime: 0,
+ })
+ const grants = await getGrants()
+ const need = new Set(grants.map((g) => g.name))
+ for (const it of items) {
+ if (!need.size) break
+ if (!it.url?.startsWith('file://')) continue
+ let path
+ try { path = decodeURIComponent(new URL(it.url).pathname) } catch { continue }
+ for (const dir of grants) {
+ if (!need.has(dir.name)) continue
+ if (await dir.queryPermission({ mode: 'readwrite' }) !== 'granted') continue
+ const prefix = await prefixFor(dir, path)
+ if (!prefix) continue
+ await learnPrefix(dir.name, prefix)
+ need.delete(dir.name)
+ learned++
+ }
+ }
+ } finally {
+ // Straight back. Holding history access after the question has been
+ // answered would be taking more than was asked for.
+ await chrome.permissions.remove({ permissions: ['history'] }).catch(() => {})
+ }
+ return { learned, declined: false }
+}
+
+const $ = (id) => document.getElementById(id)
+const esc = (s) => String(s).replace(/[&<>"]/g, (c) => (
+ { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]))
+
+const ago = (ms) => {
+ const m = Math.round((Date.now() - ms) / 60000)
+ if (m < 1) return t('agoJustNow')
+ if (m < 60) return t('agoMinutes', m)
+ const h = Math.round(m / 60)
+ if (h < 24) return t(h === 1 ? 'agoHour' : 'agoHours', h)
+ const d = Math.round(h / 24)
+ if (d < 30) return t(d === 1 ? 'agoDay' : 'agoDays', d)
+ return new Date(ms).toLocaleDateString(undefined, { day: 'numeric', month: 'short', year: 'numeric' })
+}
+
+const state = { docs: [], folder: null, q: '', sort: 'recent', view: 'docs' }
+
+/**
+ * Settings is a VIEW here, not a separate page.
+ *
+ * It used to be `options.html`: its own document, its own stylesheet, 16
+ * hardcoded colours and no dark mode — the same product in a second costume,
+ * reached by leaving the one you were in. Folding it into this shell means one
+ * design system, one back-and-forth-free navigation, and one place that knows
+ * what a folder is.
+ */
+function show(view) {
+ state.view = view
+ const docs = view === 'docs'
+ $('searchWrap').hidden = !docs
+ $('sort').hidden = !docs
+ $('new').hidden = !docs
+ $('settings').setAttribute('aria-current', String(view === 'settings'))
+ $('help').setAttribute('aria-current', String(view === 'help'))
+ $('navAll').setAttribute('aria-current', String(docs && state.folder === null))
+ if (docs) { renderSidebar(); renderGrid() }
+ else if (view === 'settings') renderSettings()
+ else renderHelp()
+}
+
+function toast(text) {
+ const t = document.createElement('div')
+ t.className = 'toast'
+ t.textContent = text
+ document.body.appendChild(t)
+ setTimeout(() => t.remove(), 2600)
+}
+
+// ------------------------------------------------------------------ loading
+async function load() {
+ const s = await status()
+ state.grants = s.folders.length
+ state.fileAccess = s.files
+ state.selfManaged = await isSelfManaged()
+ const docs = await listDocuments()
+ // Read mtimes once, here, rather than per render: sorting needs them and the
+ // grid is re-rendered on every keystroke of the search box.
+ state.docs = await Promise.all(docs.map(async (d) => {
+ let modified = 0
+ try { modified = (await d.handle.getFile()).lastModified } catch { /* vanished mid-list */ }
+ return { ...d, modified }
+ }))
+ renderSidebar()
+ renderGrid()
+}
+
+// ------------------------------------------------------------------ sidebar
+function renderSidebar() {
+ const byFolder = new Map()
+ for (const d of state.docs) byFolder.set(d.folder, (byFolder.get(d.folder) ?? 0) + 1)
+
+ $('nAll').textContent = state.docs.length || ''
+ $('navAll').setAttribute('aria-current', String(state.folder === null))
+
+ const host = $('folders')
+ host.innerHTML = ''
+ for (const [folder, n] of byFolder) {
+ const b = document.createElement('button')
+ b.className = 'navitem'
+ b.setAttribute('aria-current', String(state.folder === folder))
+ b.innerHTML = `<span class="dot"></span> ${esc(folder)} <span class="n">${n}</span>`
+ b.addEventListener('click', () => { state.folder = folder; show('docs') })
+ host.appendChild(b)
+ }
+}
+
+$('navAll').addEventListener('click', () => { state.folder = null; show('docs') })
+
+// --------------------------------------------------------------------- grid
+function visible() {
+ const q = state.q.trim().toLowerCase()
+ let docs = state.docs.filter((d) => state.folder === null || d.folder === state.folder)
+ if (q) {
+ // Match the TITLE once it is known, and the file name always — a document
+ // whose thumbnail has not loaded yet is still findable by what it is called
+ // on disk, which is what the user typed if they came from Finder.
+ // Title, file name, folder — and the document's own words once they have
+ // been read. `text` arrives with the thumbnail, so a cold list matches on
+ // names and gets deeper as it decorates, rather than making anyone wait.
+ docs = docs.filter((d) => (d.title ?? d.base).toLowerCase().includes(q)
+ || d.base.toLowerCase().includes(q) || d.folder.toLowerCase().includes(q)
+ || (d.text ?? '').toLowerCase().includes(q))
+ }
+ const by = {
+ recent: (a, b) => b.modified - a.modified,
+ name: (a, b) => (a.title ?? a.base).localeCompare(b.title ?? b.base),
+ folder: (a, b) => a.folder.localeCompare(b.folder) || b.modified - a.modified,
+ }[state.sort]
+ return docs.sort(by)
+}
+
+/**
+ * The first run, as steps rather than an apology.
+ *
+ * Installing used to land you on an empty page with a sentence. Both things
+ * that must happen are outside this extension's power — a folder you choose,
+ * and a Chrome switch no extension may touch — so the honest presentation is a
+ * short list that shows which are done, not a paragraph explaining why nothing
+ * works.
+ */
+function firstRun() {
+ const el = document.createElement('div')
+ el.className = 'empty'
+ el.innerHTML = `<h2>${t('setupTitle')}</h2><p>${t('setupLead')}</p>`
+
+ const steps = document.createElement('div')
+ steps.className = 'steps'
+ const step = (n, done, title, note, btn) => {
+ const s = document.createElement('div')
+ s.className = `step${done ? ' done' : ''}`
+ s.innerHTML = `<span class="num">${done ? '✓' : n}</span>`
+ + `<span class="txt"><b>${esc(title)}</b><small>${note}</small></span>`
+ if (btn && !done) s.querySelector('.txt').appendChild(btn)
+ steps.appendChild(s)
+ }
+
+ const pick = document.createElement('button')
+ pick.className = 'btn primary'
+ pick.textContent = t('chooseFolder')
+ pick.onclick = () => $('addFolder').click()
+ step(1, !!state.grants, t('setupStep1'), t('setupStep1Note'), pick)
+
+ step(2, state.fileAccess === true, t('setupStep2'), t('setupStep2Note'))
+
+ el.appendChild(steps)
+
+ // An unpacked install with no folders is ALSO what a botched upgrade looks
+ // like: extract the new version to a new directory, load unpacked from there,
+ // and Chrome gives it a different id — a different origin with an empty
+ // store. Everything is intact under the old id, which is still installed.
+ // Nothing here can detect that, but this is the exact screen it produces, so
+ // it is the right place to say so.
+ if (state.selfManaged) {
+ const note = document.createElement('p')
+ note.className = 'sub'
+ note.style.marginTop = '14px'
+ note.innerHTML = t('setupUpgradeNote')
+ el.appendChild(note)
+ }
+ return el
+}
+
+/** A small mark on a card's picture. Never in the body, where it would push the
+ * title around and make two cards with the same title look different lengths. */
+function badge(card, text, why) {
+ const host = card.querySelector('[data-badges]')
+ if (!host) return
+ const s = document.createElement('span')
+ s.textContent = text
+ if (why) s.title = why
+ host.appendChild(s)
+}
+
+function renderGrid() {
+ // The settings view replaces the scroller's contents, so the grid is rebuilt
+ // rather than assumed to still be there.
+ const scroll = document.querySelector('.scroll')
+ scroll.innerHTML = '<div class="grid" id="grid"></div>'
+ const grid = $('grid')
+ const docs = visible()
+ $('heading').textContent = state.folder ?? t('navAll')
+
+ if (!docs.length) {
+ // Three different emptinesses, and telling them apart is the whole job of
+ // an empty state. Nothing installed yet is a set-up problem; nothing found
+ // is a search problem; an empty folder is neither.
+ if (state.q) {
+ grid.innerHTML = `<div class="empty"><h2>${esc(t('noMatches', state.q))}</h2>`
+ + `<p>${t('searchScope')}</p></div>`
+ } else if (!state.grants) {
+ grid.appendChild(firstRun())
+ } else {
+ grid.innerHTML = `<div class="empty"><h2>${t('folderEmpty')}</h2>`
+ + `<p>${t('folderEmptyHint')}</p></div>`
+ }
+ return
+ }
+
+ for (const d of docs) {
+ const card = document.createElement('button')
+ card.className = 'card'
+ // TWO different absences looked identical, and one of them is not a
+ // problem. A document with no thumbnail has simply never been saved — a
+ // shell only gets its page-one render written into it on the first save —
+ // while a document with no path cannot be opened at all. Both used to be a
+ // pale card with a grey glyph, so five perfectly good documents read as
+ // broken. The states now say which they are, in words.
+ if (!d.path) {
+ card.disabled = true
+ card.classList.add('unplaced')
+ card.title = t('cardUnplacedTip', d.folder)
+ }
+ // Found by its CONTENT rather than its name. It lists and opens like any
+ // other, but the bridge that saves in place is a content script matching
+ // `file:///*.bento.html`, so this one will still ask where to put itself.
+ // Listing it without saying that would be a trap: the tray would look like
+ // it fully supports a document it half supports.
+ if (!d.named) {
+ card.classList.add('renamed')
+ card.title = t('cardRenamedTip', d.name)
+ }
+ card.innerHTML =
+ `<span class="shot"><span class="glyph">${d.path ? '▤' : '⤺'}</span></span>` +
+ '<span class="badges" data-badges></span>' +
+ `<span class="cardbody"><span class="txt">` +
+ `<b>${esc(d.title ?? d.base)}</b>` +
+ `<span>${esc(d.folder)} · ${esc(ago(d.modified))}</span>` +
+ `</span><span class="more" title="More">⋯</span></span>`
+ if (!d.named) badge(card, '.html', t('badgeRenamed'))
+
+ card.addEventListener('click', (ev) => {
+ if (ev.target.closest('.more')) { ev.stopPropagation(); openMenu(d, ev); return }
+ openDoc(d)
+ })
+ grid.appendChild(card)
+ void decorate(card, d)
+ }
+}
+
+/**
+ * Fill in the title and the thumbnail once the document has been read.
+ *
+ * Progressive on purpose. The title is a 300KB head; the preview sits past the
+ * document block, so a folder of twenty is twenty megabytes on a cold cache.
+ * Waiting for that before drawing anything would make the page feel broken
+ * every first run.
+ */
+async function decorate(card, d) {
+ try {
+ const meta = await describe(d)
+ d.title = meta.title
+ d.app = meta.app
+ d.text = meta.text
+ card.querySelector('b').textContent = meta.title
+ // Which Bento this is. Three apps write .bento.html now, and without this a
+ // folder of decks, notes and sheets is one undifferentiated pile. Absent on
+ // a document nobody has saved, which has no format field yet — and that is
+ // already said by "Not saved yet" rather than twice.
+ if (meta.app) {
+ const known = APPS.find((a) => a.id === meta.app)
+ badge(card, known?.name ?? meta.app, known?.blurb)
+ }
+ const shot = card.querySelector('.shot')
+ if (meta.encrypted) {
+ shot.innerHTML = `<span class="glyph" title="${t('encrypted')}">🔒</span>`
+ return
+ }
+ if (!meta.preview) {
+ // Not a failure, and it should not look like one. A shell has its
+ // page-one render written in on the FIRST SAVE, so a document that has
+ // never been saved — including every one `+ New document` creates — has
+ // nothing to show yet, and says so instead of sitting there blank.
+ if (d.path) shot.innerHTML = `<span class="label">${t('notSavedYet')}</span>`
+ return
+ }
+ shot.innerHTML = ''
+ const f = document.createElement('iframe')
+ // No scripts. This is somebody else's document and it renders inert; the
+ // preview block is a still render and needs nothing to run.
+ f.setAttribute('sandbox', '')
+ f.srcdoc = meta.preview
+ shot.appendChild(f)
+ // The preview scales itself to its viewport, so give it a real one (1280
+ // wide, in CSS) and scale the whole frame down to the card. Sizing the
+ // iframe small instead would hand it a phone-shaped viewport and it would
+ // lay page one out for that.
+ const fit = () => {
+ const scale = shot.clientWidth / 1280
+ f.style.transform = `scale(${scale})`
+ }
+ fit()
+ new ResizeObserver(fit).observe(shot)
+ } catch { /* a card without a picture is still a card */ }
+}
+
+function openDoc(d) {
+ if (!d.path) return
+ chrome.tabs.create({ url: `file://${d.path.split('/').map(encodeURIComponent).join('/')}` })
+}
+
+// --------------------------------------------------------------------- menu
+let menuEl = null
+const closeMenu = () => { menuEl?.remove(); menuEl = null }
+addEventListener('click', (e) => { if (menuEl && !menuEl.contains(e.target)) closeMenu() })
+addEventListener('keydown', (e) => { if (e.key === 'Escape') closeMenu() })
+
+function openMenu(d, ev) {
+ closeMenu()
+ const m = document.createElement('div')
+ m.className = 'menu'
+ m.style.left = `${Math.min(ev.clientX, innerWidth - 200)}px`
+ m.style.top = `${Math.min(ev.clientY, innerHeight - 200)}px`
+
+ const item = (label, fn) => {
+ const b = document.createElement('button')
+ b.textContent = label
+ b.addEventListener('click', async () => { closeMenu(); try { await fn() } catch (e) { toast(e.message) } })
+ m.appendChild(b)
+ }
+
+ if (d.path) item(t('menuOpen'), () => openDoc(d))
+ item(t('menuDuplicate'), async () => {
+ const made = await duplicate(d)
+ toast(t('duplicatedAs', made.base))
+ await load()
+ })
+ item(t('menuRename'), async () => {
+ const next = prompt(t('renamePrompt'), d.title ?? d.base)
+ if (next == null) return
+ const made = await rename(d, next)
+ toast(t('renamedTo', made.base))
+ await load()
+ })
+ if (d.path) {
+ item(t('menuCopyPath'), async () => {
+ await navigator.clipboard.writeText(d.path)
+ toast(t('pathCopied'))
+ })
+ }
+ // No Delete. A file manager that can destroy documents needs an undo, a trash
+ // and a confirmation people actually read; Finder has all three and is one
+ // keystroke away. Duplicating and renaming are recoverable, deleting is not.
+ m.appendChild(Object.assign(document.createElement('div'), { className: 'sep' }))
+ const note = document.createElement('div')
+ note.className = 'note'
+ note.textContent = d.path ? `${d.folder}/${d.name}` : t('folderNotOpenedYet', d.folder)
+ m.appendChild(note)
+
+ document.body.appendChild(m)
+ menuEl = m
+}
+
+// ------------------------------------------------------------------ notices
+async function renderNotice() {
+ const s = await status()
+ const host = $('notice')
+ host.innerHTML = ''
+ const say = (cls, html) => {
+ const el = document.createElement('div')
+ el.className = `notice ${cls}`
+ el.innerHTML = html
+ host.appendChild(el)
+ }
+
+ if (s.files === false) {
+ // One sentence, then where to go. The reason it cannot be automated is
+ // interesting to us and not to someone trying to save a document.
+ say('bad', t('noticeFileAccessOff'))
+ }
+ // An update, for installs that will never fetch one themselves. Deliberately
+ // NOT on the badge: the badge means "something is broken and saving will
+ // prompt", and being a version behind is neither.
+ const upd = await pendingUpdate()
+ if (upd?.version) {
+ // THE STEPS MATTER, and the wrong ones lose everything.
+ //
+ // An unpacked extension's ID comes from its DIRECTORY PATH. Extract the new
+ // version somewhere else and "Load unpacked" from there, and Chrome treats
+ // it as a different extension: a different origin, an empty IndexedDB, no
+ // granted folders, no learned paths, no preferences — and the old copy
+ // still installed beside it. The user lands on the first-run screen
+ // wondering where their folders went, having done the obvious thing.
+ //
+ // Replacing the files in the SAME folder keeps the id, so everything
+ // survives. That is the whole instruction, and it has to be said or the
+ // obvious path is the destructive one.
+ say('', t('updateAvailable', esc(upd.version))
+ + '<ol style="margin:8px 0 0;padding-left:18px">'
+ + `<li><a href="${esc(upd.url)}" target="_blank" rel="noopener">${t('updateStep1')}</a></li>`
+ + `<li>${t('updateStep2')}</li>`
+ + `<li>${t('updateStep3')}</li>`
+ + '</ol>')
+ }
+
+ const lapsed = s.folders.filter((f) => f.permission !== 'granted')
+ if (lapsed.length) {
+ say('bad', t('noticeLapsed', lapsed.length))
+ }
+ // The one that unlocks opening. Said here in full, because the page has room
+ // for the reason and the popup does not.
+ const unplaced = [...new Set(state.docs.filter((d) => !d.path).map((d) => d.folder))]
+ if (unplaced.length) {
+ const el = document.createElement('div')
+ el.className = 'notice'
+ el.innerHTML = t('noticeUnplaced', esc(unplaced.join(', ')))
+ const go = document.createElement('button')
+ go.className = 'btn primary'
+ go.style.marginTop = '9px'
+ go.textContent = t('findFolders')
+ go.addEventListener('click', async () => {
+ go.disabled = true
+ go.textContent = t('looking')
+ try {
+ const { learned, declined } = await locateFolders()
+ if (declined) {
+ go.disabled = false
+ go.textContent = t('findFolders')
+ // Declining is a legitimate answer, not an error. The manual route
+ // still works and costs one trip to Finder, so say so plainly rather
+ // than asking again.
+ el.innerHTML = t('findDeclined', esc(unplaced.join(' or ')))
+ return
+ }
+ await load()
+ await renderNotice()
+ toast(learned
+ ? t(learned === 1 ? 'foundFolder' : 'foundFolders', learned)
+ : t('foundNothing'))
+ } catch (e) {
+ go.disabled = false
+ go.textContent = t('findFolders')
+ toast(e.message)
+ }
+ })
+ el.appendChild(document.createElement('br'))
+ el.appendChild(go)
+ host.appendChild(el)
+ }
+}
+
+// ------------------------------------------------------------------ actions
+$('q').addEventListener('input', (e) => { state.q = e.target.value; renderGrid() })
+$('sort').addEventListener('change', (e) => { state.sort = e.target.value; renderGrid() })
+
+// `/` focuses search, the convention everywhere text is listed. Not while
+// typing in a field, or it eats the character.
+addEventListener('keydown', (e) => {
+ if (e.key === '/' && !/^(INPUT|TEXTAREA|SELECT)$/.test(document.activeElement?.tagName)) {
+ e.preventDefault(); $('q').focus()
+ }
+ if (e.key === 'Escape' && document.activeElement === $('q')) {
+ $('q').value = ''; state.q = ''; renderGrid()
+ }
+})
+
+$('addFolder').addEventListener('click', async () => {
+ try {
+ const dir = await window.showDirectoryPicker({ mode: 'readwrite' })
+ await dir.requestPermission({ mode: 'readwrite' })
+ const dirs = await getGrants()
+ for (const existing of dirs) if (await existing.isSameEntry(dir)) return
+ await putGrants([...dirs, dir])
+ await load()
+ await renderNotice()
+ } catch (e) {
+ if (e?.name !== 'AbortError') toast(e.message)
+ }
+})
+
+/**
+ * Which Bento to make.
+ *
+ * Every other operation here is app-blind: `.bento.html` is the whole family,
+ * they share a kernel, and a document says what it is by carrying its own
+ * runtime. Creating one is the single moment that has to ask, because there is
+ * no document yet to ask.
+ */
+$('new').addEventListener('click', async (ev) => {
+ const grants = await getGrants()
+ if (!grants.length) { $('addFolder').click(); return }
+ // Into the folder being looked at, when one is; otherwise the first granted.
+ // A new document appearing in a folder you are not looking at is a small
+ // mystery, and mysteries are what a file manager exists to prevent.
+ const target = state.folder
+ ? grants.find((g) => g.name === state.folder) ?? grants[0]
+ : grants[0]
+
+ closeMenu()
+ const m = document.createElement('div')
+ m.className = 'menu'
+ const r = ev.target.getBoundingClientRect()
+ m.style.left = `${Math.max(12, r.right - 200)}px`
+ m.style.top = `${r.bottom + 6}px`
+
+ for (const app of APPS) {
+ const b = document.createElement('button')
+ b.innerHTML = `<b>${esc(app.name)}</b> <span style="color:var(--dim)">${esc(app.blurb)}</span>`
+ b.addEventListener('click', async () => {
+ closeMenu()
+ const btn = $('new')
+ btn.disabled = true
+ btn.textContent = t('fetchingApp', app.name)
+ try {
+ // The signed release, fetched now, rather than a copy bundled in the
+ // extension: a document made here is the same build everyone else has
+ // today, and the extension never needs re-reviewing to keep up.
+ const made = await newDocument(target, 'Untitled', { app: app.id })
+ toast(t('createdIn', made.base, `${made.app} ${made.version}`, target.name))
+ await load()
+ } catch (e) {
+ toast(e.message)
+ } finally {
+ btn.disabled = false
+ btn.textContent = '+ New document'
+ }
+ })
+ m.appendChild(b)
+ }
+ const note = document.createElement('div')
+ note.className = 'note'
+ note.textContent = t('intoFolder', target.name)
+ m.appendChild(Object.assign(document.createElement('div'), { className: 'sep' }))
+ m.appendChild(note)
+
+ document.body.appendChild(m)
+ menuEl = m
+})
+
+$('settings').addEventListener('click', () => show('settings'))
+$('help').addEventListener('click', () => show('help'))
+
+/**
+ * What this gives you, what it needs, and where it came from — in one place.
+ *
+ * Onboarding, help and about are the same three questions asked at different
+ * moments: "what is this", "how do I use it", "who made it". Three separate
+ * surfaces would repeat each other and drift; one view answers all three, and
+ * a fresh install is simply sent here.
+ *
+ * It shows LIVE state, not a leaflet. The setup steps tick themselves off, so
+ * this is also the page to come back to when something has stopped working —
+ * which is when people actually look for help.
+ */
+async function renderHelp() {
+ $('heading').textContent = t('navHelp')
+ const s = await status()
+ const mine = chrome.runtime.getManifest().version
+ const wrap = document.createElement('div')
+ wrap.className = 'panel'
+
+ const section = (title, sub) => {
+ const el = document.createElement('section')
+ el.innerHTML = `<h2>${esc(title)}</h2>${sub ? `<p class="sub">${sub}</p>` : ''}`
+ wrap.appendChild(el)
+ return el
+ }
+
+ // --- what it is for
+ const what = section(t('helpWhatTitle'), t('helpWhatSub'))
+ const tour = document.createElement('div')
+ tour.className = 'tour'
+ for (const [title, body] of [
+ [t('tourSaveTitle'), t('tourSaveBody')],
+ [t('tourFindTitle'), t('tourFindBody')],
+ [t('tourSwitchTitle'), t('tourSwitchBody')],
+ [t('tourNewTitle'), t('tourNewBody')],
+ ]) {
+ const c = document.createElement('div')
+ c.className = 'card'
+ c.innerHTML = `<b>${esc(title)}</b><p>${body}</p>`
+ tour.appendChild(c)
+ }
+ what.appendChild(tour)
+
+ // --- what it needs, live
+ const needs = section(t('helpNeedsTitle'), t('helpNeedsSub'))
+ const step = (done, title, note) => {
+ const el = document.createElement('div')
+ el.className = `row${done ? '' : ''}`
+ el.innerHTML = `<span class="dot ${done ? 'ok' : 'bad'}"></span><b>${esc(title)}</b>`
+ + `<span class="note">${note}</span>`
+ needs.appendChild(el)
+ return el
+ }
+ const folderRow = step(s.folders.length > 0, t('helpFolder'),
+ s.folders.length ? t('helpFolderGranted', s.folders.length) : t('helpFolderNone'))
+ if (!s.folders.length) {
+ const b = document.createElement('button')
+ b.className = 'btn'
+ b.textContent = t('chooseFolder')
+ b.onclick = () => $('addFolder').click()
+ folderRow.appendChild(b)
+ }
+ step(s.files !== false, t('setAccessTitle'),
+ s.files === false ? t('helpAccessOff')
+ : s.files === null ? t('helpAccessUnknown') : t('helpAccessOn'))
+
+ // --- what it never does
+ section(t('helpNeverTitle'), t('helpNeverSub'))
+
+ // --- where it came from
+ const about = section(t('helpAboutTitle'), t('helpAboutSub', esc(mine)))
+ const links = document.createElement('div')
+ links.className = 'links'
+ for (const [label, href] of [
+ ['bento.page', 'https://bento.page'],
+ [t('linkSource'), 'https://github.com/nyblnet/bento'],
+ [t('linkIssues'), 'https://github.com/nyblnet/bento/issues'],
+ [t('linkReleases'), 'https://github.com/nyblnet/bento/releases'],
+ ]) {
+ const a = document.createElement('a')
+ a.className = 'btn'
+ a.href = href
+ a.target = '_blank'
+ a.rel = 'noopener'
+ a.textContent = label
+ links.appendChild(a)
+ }
+ about.appendChild(links)
+
+ const scroll = document.querySelector('.scroll')
+ scroll.innerHTML = ''
+ scroll.appendChild(wrap)
+}
+
+/**
+ * Settings: the folders, and the two permissions that both fail silently.
+ *
+ * Everything here was prose in the old options page. It is now rows, because a
+ * folder is a thing with a state and an action, and a paragraph about it is
+ * neither.
+ */
+async function renderSettings() {
+ $('heading').textContent = t('navSettings')
+ const s = await status()
+ const dirs = await getGrants()
+ const wrap = document.createElement('div')
+ wrap.className = 'panel'
+
+ const section = (title, sub) => {
+ const el = document.createElement('section')
+ el.innerHTML = `<h2>${esc(title)}</h2><p class="sub">${sub}</p>`
+ wrap.appendChild(el)
+ return el
+ }
+
+ // --- folders
+ const folders = section(t('navFolders'), t('setFoldersSub'))
+ if (!dirs.length) {
+ const p = document.createElement('p')
+ p.className = 'dim'
+ p.textContent = t('noneYet')
+ folders.appendChild(p)
+ }
+ dirs.forEach((dir, i) => {
+ const granted = s.folders[i]?.permission === 'granted'
+ const row = document.createElement('div')
+ row.className = 'row'
+ row.innerHTML = `<span class="dot ${granted ? 'ok' : 'bad'}"></span><b>${esc(dir.name)}</b>`
+ + `<span class="note">${granted ? t('savesInPlace') : t('needsReconnecting')}</span>`
+ if (!granted) {
+ const renew = document.createElement('button')
+ renew.className = 'btn'
+ renew.textContent = t('reconnect')
+ renew.title = t('reconnectTip')
+ renew.onclick = () => act(async () => {
+ if (await dir.requestPermission({ mode: 'readwrite' }) === 'granted') await putGrants(dirs)
+ })
+ row.appendChild(renew)
+ }
+ const drop = document.createElement('button')
+ drop.className = 'btn'
+ drop.textContent = t('remove')
+ // This list is the only place access can be withdrawn — Chrome offers no
+ // control for extension origins — so Remove is a real revoke: with no
+ // folder stored there is nothing to write through.
+ drop.title = t('removeTip')
+ drop.onclick = () => act(async () => {
+ const next = [...dirs]; next.splice(i, 1); await putGrants(next)
+ })
+ row.appendChild(drop)
+ folders.appendChild(row)
+ })
+ const add = document.createElement('button')
+ add.className = 'btn'
+ add.textContent = t('addFolder')
+ add.onclick = () => $('addFolder').click()
+ folders.appendChild(add)
+
+ // --- the permission nothing can request
+ const access = section(t('setAccessTitle'), t('setAccessSub'))
+ const row = document.createElement('div')
+ row.className = 'row'
+ const ok = s.files === true
+ row.innerHTML = `<span class="dot ${ok ? 'ok' : s.files === false ? 'bad' : 'meh'}"></span>`
+ + `<b>${ok ? t('stateOn') : s.files === false ? t('stateOff') : t('stateUnknown')}</b>`
+ + `<span class="note">${ok
+ ? t('accessOnNote')
+ : s.files === false ? t('accessOffNote') : t('accessUnknownNote')}</span>`
+ access.appendChild(row)
+
+ // --- version, and whether this copy can update itself
+ const mine = chrome.runtime.getManifest().version
+ const selfManaged = await isSelfManaged()
+ const upd = await pendingUpdate()
+ const ver = section(t('setVersionTitle'),
+ selfManaged ? t('setVersionUnpacked') : t('setVersionStore'))
+ const vrow = document.createElement('div')
+ vrow.className = 'row'
+ vrow.innerHTML = `<span class="dot ${upd?.version ? 'meh' : 'ok'}"></span><b>${esc(mine)}</b>`
+ + `<span class="note">${upd?.version
+ ? t('versionAvailable', esc(upd.version))
+ : selfManaged ? t('versionUpToDate') : t('versionManaged')}</span>`
+ if (upd?.version) {
+ const link = document.createElement('a')
+ link.className = 'btn'
+ link.href = upd.url
+ link.target = '_blank'
+ link.rel = 'noopener'
+ link.textContent = t('getIt')
+ vrow.appendChild(link)
+ }
+ if (selfManaged) {
+ const now = document.createElement('button')
+ now.className = 'btn'
+ now.textContent = t('checkNow')
+ // `force`: pressing a button IS consent, whatever the preference says.
+ now.onclick = () => act(async () => { await checkForUpdate({ force: true }) })
+ vrow.appendChild(now)
+ }
+ ver.appendChild(vrow)
+
+ // The switch for the one outbound request this extension makes.
+ //
+ // THIS WAS CLAIMED AND NOT DELIVERED. The commit that argued for "on by
+ // default, switchable, disclosed" shipped the preference in update.js, the
+ // rig that covers it, and no way for anyone to change it — a script's anchor
+ // text did not match, `String.replace` no-opped, and nothing asserted. The
+ // argument for the default rests entirely on this control existing.
+ if (selfManaged) {
+ const on = await autoCheckEnabled()
+ const pref = document.createElement('label')
+ pref.className = 'row'
+ pref.style.cursor = 'pointer'
+ const box = document.createElement('input')
+ box.type = 'checkbox'
+ box.checked = on
+ box.onchange = () => act(async () => { await setAutoCheck(box.checked) })
+ const txt = document.createElement('span')
+ txt.className = 'note'
+ txt.innerHTML = t('autoCheckPref')
+ pref.append(box, txt)
+ ver.appendChild(pref)
+ }
+ // The package is byte-reproducible, so a published digest is checkable by the
+ // person doing the install — which is the only verification available when
+ // the browser is not doing the updating.
+ if (upd?.sha256) {
+ const sum = document.createElement('p')
+ sum.className = 'sub'
+ sum.style.marginTop = '8px'
+ sum.innerHTML = t('expectedSha', `<code>${esc(upd.sha256)}</code>`)
+ ver.appendChild(sum)
+ }
+
+ // --- what the extension will never do
+ const about = section(t('setReachTitle'), t('setReachSub'))
+ void about
+
+ const scroll = document.querySelector('.scroll')
+ scroll.innerHTML = ''
+ scroll.appendChild(wrap)
+}
+
+/** Run a settings action, then redraw both the settings view and the library —
+ * adding or removing a folder changes what documents exist. */
+async function act(fn) {
+ try {
+ await fn()
+ await load()
+ await renderSettings()
+ await renderNotice()
+ } catch (e) {
+ if (e?.name !== 'AbortError') toast(e.message)
+ }
+}
+
+/**
+ * Notice when the answer arrives.
+ *
+ * The one unlock step happens OUTSIDE this page: a document is opened from
+ * Finder, its content script says hello, and the worker records where that
+ * folder lives. Nothing tells the page. Without this, the user does exactly what
+ * was asked, comes back to a tab still showing greyed-out cards, and reasonably
+ * concludes it did not work.
+ *
+ * Coming back to the tab is the signal — you cannot open a document from Finder
+ * without leaving it. Cheap to act on: the document list is a directory walk and
+ * the expensive part, reading each file, is cached by size and mtime.
+ */
+document.addEventListener('visibilitychange', () => {
+ if (document.visibilityState !== 'visible') return
+ void (async () => {
+ const before = state.docs.filter((d) => d.path).length
+ await load()
+ await renderNotice()
+ const after = state.docs.filter((d) => d.path).length
+ if (after > before) toast(`${state.folder ?? 'Your documents'} — unlocked`)
+ })()
+})
+
+// A fresh install is sent here by the worker (`#welcome`), because the first
+// question is "what did I just install and what does it want" — and a grid of
+// documents it cannot see yet answers none of it.
+localize()
+if (location.hash === '#welcome' || location.hash === '#help') show('help')
+
+await load()
+await renderNotice()
+if (location.hash === '#welcome' || location.hash === '#help') show('help')
diff --git a/tray/webext/src/i18n.js b/tray/webext/src/i18n.js
new file mode 100644
index 00000000..f2ecaf60
--- /dev/null
+++ b/tray/webext/src/i18n.js
@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+//
+// Every word the extension says, in the reader's language.
+//
+// WHY NOT THE APP'S SYSTEM. `slides/src/i18n.ts` uses the English string as the
+// key, compiles catalogues into the bundle, and lets the VIEWER pick a language
+// at runtime. That design exists because a document travels: it is opened by
+// people who did not write it, on machines that are not the author's, and the
+// reader chooses. An extension does not travel. It belongs to one browser, and
+// browser chrome should speak the browser's language — which is exactly what
+// `chrome.i18n` does, and the only mechanism that can also localise the store
+// listing.
+//
+// The cost, accepted deliberately: `chrome.i18n` has NO runtime switching. There
+// is no language picker here as there is in the app's About dialog, because
+// Chrome resolves the locale once at load from its own UI language. Anyone who
+// wants the extension in another language changes it in Chrome, which is where
+// they would look.
+//
+// A MISSING KEY SHOWS ITSELF. `getMessage` returns an empty string for a key it
+// does not know, so a typo silently blanks a button. Falling back to the key
+// name makes it read `helpAboutTitle` instead — ugly on purpose, and impossible
+// to miss in review.
+
+/**
+ * One message, with positional substitutions.
+ *
+ * t('foundFolders', 2) -> "Found 2 folders"
+ *
+ * Chrome takes substitutions as strings, so numbers are coerced here rather
+ * than at every call site.
+ */
+export const t = (key, ...subs) => {
+ try {
+ return chrome.i18n.getMessage(key, subs.map((s) => String(s))) || key
+ } catch {
+ return key // no chrome.i18n: a test rig, or a page loaded outside the extension
+ }
+}
+
+/**
+ * Fill the static markup.
+ *
+ * Chrome substitutes `__MSG_x__` in the manifest and in CSS, but NOT in HTML —
+ * so anything written into a page has to be filled at load. Attributes are
+ * separate because a placeholder and a title are not text nodes and would
+ * otherwise have to be set from script, scattering strings back into the code
+ * this exists to keep them out of.
+ *
+ * <h1 data-i18n="helpTitle"></h1>
+ * <input data-i18n-placeholder="searchPlaceholder">
+ * <button data-i18n-title="moreActions">…</button>
+ *
+ * `data-i18n-html` exists for the few strings carrying <b> or <code>. The
+ * source is our own catalogue, never a document or a message, so it is markup
+ * we wrote — but it is a separate attribute so that using it is a decision
+ * rather than the default.
+ */
+/**
+ * Right-to-left, when the browser's language is.
+ *
+ * The app already does this deliberately (`slides/src/i18n.ts RTL_LANGS`), and
+ * the extension shipped Arabic, Persian, Hebrew and Urdu catalogues into a
+ * layout that was left-to-right in fourteen places. Setting `dir` is only half
+ * of it — the CSS had to stop naming sides, which is why it uses
+ * `inset-inline-start` and `text-align: start` rather than `left`.
+ *
+ * `chrome.i18n.getUILanguage()` is the browser's language, which is the one
+ * Chrome resolved the catalogue from, so the direction cannot disagree with the
+ * words on screen.
+ */
+const RTL = new Set(['ar', 'fa', 'he', 'iw', 'ur', 'ps', 'sd', 'ug', 'yi'])
+
+export function applyDirection(root = document) {
+ try {
+ const lang = chrome.i18n.getUILanguage()
+ root.documentElement.lang = lang
+ root.documentElement.dir = RTL.has(lang.split('-')[0].toLowerCase()) ? 'rtl' : 'ltr'
+ } catch {
+ /* no chrome.i18n: leave the document as authored */
+ }
+}
+
+export function localize(root = document) {
+ applyDirection(root)
+ for (const el of root.querySelectorAll('[data-i18n]')) {
+ el.textContent = t(el.dataset.i18n)
+ }
+ for (const el of root.querySelectorAll('[data-i18n-html]')) {
+ el.innerHTML = t(el.dataset.i18nHtml)
+ }
+ for (const el of root.querySelectorAll('[data-i18n-placeholder]')) {
+ el.placeholder = t(el.dataset.i18nPlaceholder)
+ }
+ for (const el of root.querySelectorAll('[data-i18n-title]')) {
+ el.title = t(el.dataset.i18nTitle)
+ }
+}
diff --git a/tray/webext/src/library.js b/tray/webext/src/library.js
new file mode 100644
index 00000000..6ab1a51c
--- /dev/null
+++ b/tray/webext/src/library.js
@@ -0,0 +1,390 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+//
+// Your documents — the thing the extension is actually for.
+//
+// The popup used to be a permissions control panel: "local file access is on,
+// folder: documents". True, and nobody wants it. tray/ios is a
+// UIDocumentBrowserViewController — you see your documents and tap one — and
+// that is the right shape here too. Permissions are plumbing and belong at the
+// bottom, speaking only when broken.
+//
+// ENUMERATION IS FINE HERE, and that is worth saying because `background.js`
+// went to some trouble to stop enumerating. The difference is who is waiting:
+// resolving a SAVE must not walk a folder, because the user is mid-⌘S and a
+// granted home directory would hang it. Listing is user-initiated, happens when
+// the popup opens, is bounded, and its results are cached. Different job,
+// different rules.
+
+import { CACHE, get, put, prefixes } from './db.js'
+import { getGrants } from './status.js'
+
+/** How deep to look, and how many documents to show. A folder of documents is
+ * not a filesystem; someone who granted a home directory should get a useful
+ * list quickly rather than a complete one slowly. */
+const MAX_DEPTH = 4
+const MAX_DOCS = 300
+/** How many unrecognised .html files to open and look inside, per listing. */
+const MAX_SNIFFS = 400
+
+/** Enough to reach the title, which sits in the `#bento-doc` block that starts
+ * a few KB in. Measured on a real deck: block at 5.8KB, title inside it. The
+ * block itself runs to megabytes when a document carries images, which is the
+ * trap an earlier metadata reader fell into — it looked for the CLOSING tag
+ * and so found nothing in any document with a picture in it. Reading a fixed
+ * head and matching the field directly avoids needing the end at all. */
+const HEAD_BYTES = 300 * 1024
+
+/** Named like one of ours. Free to decide — no read at all. */
+const namedDoc = (name) => /\.bento\.html$/i.test(name)
+
+/** Any other local page, which MIGHT be one of ours under a different name. */
+const maybeDoc = (name) => /\.html?$/i.test(name) && !namedDoc(name)
+
+/**
+ * How much of a file to read before deciding whether it is a Bento document.
+ *
+ * The marker is `id="bento-doc"` — the splice contract every Bento app honours
+ * (docs/PLATFORM.md §2), frozen because old updaters depend on it. Measured on
+ * a real shell it sits 5.8KB in, after the chrome and the notice, so 64KB is
+ * generous. It is deliberately NOT the 300KB head used for titles: this runs
+ * against every stray .html in a granted folder, and most of them are not ours.
+ */
+const SNIFF_BYTES = 64 * 1024
+const MARKER = 'id="bento-doc"'
+
+/**
+ * Is this actually a Bento document, whatever it is called?
+ *
+ * A Bento document is a Bento document because of what is INSIDE it. The name
+ * is a convention, and conventions get broken by people: renamed to `deck.html`
+ * to email it, saved by a browser that appended `(1)`, downloaded as
+ * `Q3.html`. Those are still documents this extension can open, and until now
+ * they were invisible because the filter was a regular expression on the name.
+ *
+ * Cheap enough to do honestly: the marker is in the first few KB, the verdict
+ * is cached by size and mtime like everything else read here, and a file that
+ * is not ours is rejected after one 64KB read that never happens again.
+ */
+async function sniff(handle, cacheGet, cachePut) {
+ const file = await handle.getFile()
+ const key = `sniff:${handle.name}:${file.size}:${file.lastModified}`
+ const hit = await cacheGet(key)
+ if (hit !== null && hit !== undefined) return hit.isDoc
+ const head = await file.slice(0, SNIFF_BYTES).text()
+ const isDoc = head.includes(MARKER)
+ try { await cachePut(key, { isDoc }) } catch { /* best effort */ }
+ return isDoc
+}
+
+/**
+ * Every Bento document in the granted folders.
+ *
+ * Returns descriptors, not contents: name, folder, route, size, mtime. Reading
+ * the documents themselves is a separate, cached step (`describe`), because a
+ * folder of twenty decks is twenty megabytes and the list has to appear now.
+ */
+export async function listDocuments(deps = {}) {
+ const grants = await (deps.getGrants ?? getGrants)()
+ const known = await (deps.prefixes ?? prefixes)()
+ const cacheGet = deps.get ?? ((k) => get(CACHE, k))
+ const cachePut = deps.put ?? ((k, v) => put(CACHE, k, v))
+ const out = []
+
+ // Reading is only free the first time. A granted home directory can hold
+ // thousands of unrelated .html files, and sniffing every one on every popup
+ // open would be a real cost for a rare case — so the budget is per listing,
+ // and named documents never spend from it.
+ let sniffs = MAX_SNIFFS
+
+ const walk = async (dir, root, rel, depth) => {
+ if (depth > MAX_DEPTH || out.length >= MAX_DOCS) return
+ for await (const [name, handle] of dir.entries()) {
+ if (out.length >= MAX_DOCS) return
+ if (handle.kind === 'file') {
+ let named = namedDoc(name)
+ if (!named) {
+ // Not named like ours — but a document is a document because of what
+ // is inside it, and names get changed by people. Look, once, cheaply.
+ if (!maybeDoc(name) || sniffs <= 0) continue
+ sniffs--
+ let is = false
+ try { is = await sniff(handle, cacheGet, cachePut) } catch { continue }
+ if (!is) continue
+ }
+ out.push({
+ name,
+ named,
+ base: name.replace(/\.bento\.html$/i, '').replace(/\.html?$/i, ''),
+ folder: root.name,
+ rel: [...rel, name],
+ // Absolute path only if this folder has taught us where it lives.
+ // Without it the row still renders — it just cannot be opened, and
+ // says so, rather than silently doing nothing when clicked.
+ path: known[root.name] ? `${known[root.name]}/${[...rel, name].join('/')}` : null,
+ handle,
+ // The directory the document actually sits in, so the page can act on
+ // it — duplicate beside it, rename within it — without walking again.
+ parent: dir,
+ })
+ } else if (handle.kind === 'directory' && !name.startsWith('.')) {
+ await walk(handle, root, [...rel, name], depth + 1)
+ }
+ }
+ }
+
+ for (const dir of grants) {
+ // A lapsed folder cannot be read at all; skipping it beats throwing, since
+ // the other folders are still perfectly listable.
+ if (await dir.queryPermission({ mode: 'readwrite' }) !== 'granted') continue
+ try { await walk(dir, dir, [], 0) } catch { /* unreadable folder: skip */ }
+ }
+ return out
+}
+
+/** Cache key. Includes size and mtime so an edited document re-reads itself,
+ * and nothing has to be invalidated by hand. */
+const keyFor = (doc, file) => `${doc.folder}/${doc.rel.join('/')}:${file.size}:${file.lastModified}`
+
+/**
+ * What a document is called, and what its first page looks like.
+ *
+ * TITLE. Documents are named `Q3-board.bento.html`; the document knows it is
+ * "Q3 Board Review". Showing the filename when the title is right there is the
+ * difference between a file list and a document list.
+ *
+ * PREVIEW. Every save already writes a still render of page one into the shell
+ * (`kernel/src/preview.ts`) so that file managers can thumbnail it. This IS a
+ * file manager. The block is self-contained and scales itself to whatever
+ * viewport it lands in, so it drops straight into a small sandboxed iframe with
+ * no work — which is precisely what it was designed for.
+ *
+ * An ENCRYPTED document deliberately carries no preview: a plaintext title page
+ * beside the ciphertext is the leak the password exists to prevent. So a
+ * missing preview is not a failure here, it is a signal, and the caller shows a
+ * lock rather than a blank.
+ */
+export async function describe(doc, deps = {}) {
+ const cacheGet = deps.get ?? ((k) => get(CACHE, k))
+ const cachePut = deps.put ?? ((k, v) => put(CACHE, k, v))
+ const file = await doc.handle.getFile()
+ const key = keyFor(doc, file)
+ const hit = await cacheGet(key)
+ if (hit) return hit
+
+ const head = await file.slice(0, HEAD_BYTES).text()
+ const title = head.match(/"title"\s*:\s*"((?:[^"\\]|\\.){0,200})"/)?.[1]
+ // Which Bento this is. The format field is the document's own answer — the
+ // extension supports three apps now and the UI never said which one a
+ // document was, so a folder of decks and sheets looked like one undifferentiated
+ // pile. A pristine shell has no document yet, so no format: that is not a
+ // failure, it is a document nobody has saved.
+ const app = head.match(/"format"\s*:\s*"bento\/([a-z]+)"/)?.[1] ?? null
+ const encrypted = /"format"\s*:\s*"bento\/enc"/.test(head) || /data-bento-enc/.test(head)
+
+ // The preview sits AFTER the document block — a quarter of the way into a
+ // 900KB file, measured — so unlike the title it cannot be had from the head.
+ // This is the expensive read, and the only reason the cache exists.
+ // ONE read, two answers. The preview and the searchable text both come out of
+ // the same bytes, so an encrypted document costs nothing extra and everything
+ // else costs exactly one pass.
+ let preview = null
+ let text = null
+ if (!encrypted) {
+ const whole = await file.text()
+ const start = whole.indexOf('<div data-bento-preview')
+ const end = start === -1 ? -1 : whole.indexOf('<script data-bento-preview', start)
+ if (start !== -1 && end > start) preview = whole.slice(start, end)
+ text = extractText(whole)
+ }
+
+ const meta = {
+ title: title ? title.replace(/\\(.)/g, '$1') : doc.base,
+ app,
+ // What the document SAYS, so search can find a deck by a phrase on a slide
+ // rather than only by what somebody happened to call the file. Free in I/O:
+ // the same read that produced the preview.
+ text,
+ encrypted,
+ preview,
+ size: file.size,
+ modified: file.lastModified,
+ }
+ // Best effort: a cache that cannot be written costs a re-read, nothing more.
+ try { await cachePut(key, meta) } catch { /* quota, private mode */ }
+ return meta
+}
+
+/** How much extracted prose to keep per document. Enough for any phrase
+ * somebody would search for; far short of storing the document twice. */
+const TEXT_BUDGET = 40 * 1024
+
+/**
+ * The words a document actually contains.
+ *
+ * Search used to cover the title, the file name and the folder — which finds a
+ * deck you can already name. What you usually remember is a phrase ON a slide,
+ * and the bytes to answer that were already read for the thumbnail and then
+ * thrown away.
+ *
+ * Deliberately NOT a JSON parse. The document block runs to megabytes with
+ * images inline, every app shapes it differently (slides put prose in
+ * `element.html`, spaces in blocks, dash in cells), and a parser that has to
+ * know the format is a parser that breaks when the format moves. Pulling string
+ * VALUES out — `:"…"`, never keys — is format-agnostic and degrades to "finds
+ * less" rather than "throws".
+ *
+ * Data URIs go first: one embedded image is bigger than every word in the
+ * document, and they would dominate both the work and the budget.
+ */
+function extractText(html) {
+ const start = html.indexOf(MARKER)
+ if (start === -1) return null
+ const end = html.indexOf('</script>', start)
+ if (end === -1) return null
+
+ let block = html.slice(start, end)
+ block = block.replace(/data:[^"\\]{200,}/g, ' ') // embedded media
+ const out = []
+ let size = 0
+ for (const m of block.matchAll(/:"((?:[^"\\]|\\.){1,400})"/g)) {
+ const v = m[1]
+ if (!/[A-Za-z]{3,}/.test(v)) continue // ids, colours, numbers
+ out.push(v)
+ size += v.length
+ if (size > TEXT_BUDGET) break
+ }
+ return out.join(' ')
+ .replace(/<[^>]{1,200}>/g, ' ') // element html
+ .replace(/&[a-z]+;|&#\d+;/gi, ' ')
+ .replace(/\s+/g, ' ')
+ .trim()
+ .slice(0, TEXT_BUDGET) || null
+}
+
+/**
+ * The `+` from tray/ios, which mints a new document from a seed.
+ *
+ * iOS bundles that seed. We deliberately do not: bundling an app shell would
+ * put a copy of Bento inside the extension, to drift from the real release and
+ * to be re-reviewed on every update — the same trap tray/ios avoided by letting
+ * documents carry their own runtime. Fetching the current signed release
+ * instead means a document created here is the same version everyone else has,
+ * the same day.
+ *
+ * Create-only, and the name is derived here rather than taken from anywhere —
+ * the same rule as `backup`. Nothing existing is ever replaced.
+ */
+/**
+ * The Bento apps, each with its own signed release channel.
+ *
+ * They all write `.bento.html`, all carry their own runtime, and all save
+ * through the same kernel — so listing, opening, thumbnails and in-place saving
+ * never needed to know which app a document belongs to, and still do not. This
+ * list exists for ONE thing: creating a new document means choosing what it
+ * should be.
+ *
+ * Adding an app here is the whole integration; nothing else in the extension
+ * asks which app it is looking at.
+ */
+export const APPS = [
+ { id: 'slides', name: 'Slides', blurb: 'Presentations',
+ manifest: 'https://bento.page/releases/slides/manifest.json' },
+ { id: 'spaces', name: 'Spaces', blurb: 'Notes and pages',
+ manifest: 'https://bento.page/releases/spaces/manifest.json' },
+ { id: 'dash', name: 'Dash', blurb: 'Data and sheets',
+ manifest: 'https://bento.page/releases/dash/manifest.json' },
+]
+
+/**
+ * A free name in `dir`, counting on the BASE.
+ *
+ * `Untitled 2.bento.html`, never `Untitled.bento 2.html`. A double extension
+ * defeats naive counters — including UIKit's, which reads `.bento.html` as the
+ * name "Untitled.bento" plus extension "html" and inserts before the last
+ * extension only. tray/ios had to write its own for exactly this.
+ */
+export async function freeName(dir, wantedBase) {
+ let base = wantedBase
+ for (let n = 2; n < 999; n++) {
+ let taken = true
+ try { await dir.getFileHandle(`${base}.bento.html`) } catch (e) { taken = e?.name !== 'NotFoundError' }
+ if (!taken) return { base, name: `${base}.bento.html` }
+ base = `${wantedBase} ${n}`
+ }
+ throw new Error('too many documents with that name')
+}
+
+/**
+ * Copy a document beside itself.
+ *
+ * Byte-for-byte, deliberately: a Bento document carries its own runtime, its
+ * own collaboration keys and its own identity, and re-deriving any of that here
+ * would make a copy that is subtly not the original. Whether a duplicate should
+ * get a fresh `docId` is the DOCUMENT's business — Bento's own "Duplicate as
+ * new deck" exists for that — and a file manager has no standing to decide it.
+ */
+export async function duplicate(doc) {
+ const { name, base } = await freeName(doc.parent, `${doc.base} copy`)
+ const bytes = await (await doc.handle.getFile()).arrayBuffer()
+ const out = await doc.parent.getFileHandle(name, { create: true })
+ const w = await out.createWritable()
+ await w.write(bytes)
+ await w.close()
+ return { name, base }
+}
+
+/**
+ * Rename a document.
+ *
+ * The File System Access API has no rename, so this is write-then-remove — in
+ * that ORDER, and never the reverse. If the write fails the original is
+ * untouched; if the remove fails the worst case is two copies, which is a
+ * nuisance rather than a loss. Removing first would put the only copy of
+ * somebody's document in a variable.
+ */
+export async function rename(doc, wantedBase) {
+ // This string came from a prompt box and is about to become a filename.
+ // Separators go first, so nothing can escape the folder; then the extension,
+ // so typing it does not double it; then leading dots, because a document
+ // called `.something` is invisible in every file manager including this one
+ // — it would vanish from the list the moment it was renamed.
+ const clean = wantedBase.trim()
+ .replace(/[/\\:\0]/g, '')
+ .replace(/\.bento\.html$/i, '')
+ .replace(/\.{2,}/g, '.')
+ .replace(/^\.+/, '')
+ .trim()
+ if (!clean) throw new Error('a document needs a name')
+ if (clean === doc.base) return { name: doc.name, base: doc.base }
+
+ const { name, base } = await freeName(doc.parent, clean)
+ const bytes = await (await doc.handle.getFile()).arrayBuffer()
+ const out = await doc.parent.getFileHandle(name, { create: true })
+ const w = await out.createWritable()
+ await w.write(bytes)
+ await w.close()
+ await doc.parent.removeEntry(doc.name)
+ return { name, base }
+}
+
+export async function newDocument(dir, wantedBase = 'Untitled', deps = {}) {
+ const net = deps.fetch ?? fetch
+ const app = APPS.find((a) => a.id === deps.app) ?? APPS[0]
+ const res = await net(app.manifest, { cache: 'no-store' })
+ if (!res.ok) throw new Error(`could not reach the ${app.name} release server (${res.status})`)
+ const manifest = await res.json()
+ const url = manifest?.url
+ if (!url) throw new Error('the release server did not offer a build')
+
+ const shell = await net(url, { cache: 'no-store' })
+ if (!shell.ok) throw new Error(`could not download the app (${shell.status})`)
+ const html = await shell.text()
+
+ const { name, base } = await freeName(dir, wantedBase)
+ const handle = await dir.getFileHandle(name, { create: true })
+ const w = await handle.createWritable()
+ await w.write(html)
+ await w.close()
+ return { name, base, version: manifest.version, app: app.name }
+}
diff --git a/tray/webext/src/options.html b/tray/webext/src/options.html
deleted file mode 100644
index 22561172..00000000
--- a/tray/webext/src/options.html
+++ /dev/null
@@ -1,23 +0,0 @@
-<!doctype html>
-<meta charset="utf-8">
-<title>Bento Tray</title>
-<style>
- body { font: 15px/1.6 -apple-system, system-ui, sans-serif; max-width: 34rem; margin: 3rem auto; padding: 0 1.4rem; color: #1e2a3a; }
- h1 { font-size: 19px; margin-bottom: .2rem; }
- .sub { color: #586a80; margin-top: 0; }
- button { font: inherit; padding: .5rem 1rem; border: 1px solid #c8d0dc; border-radius: 8px; background: #fff; cursor: pointer; }
- button:hover { background: #f5f7fa; }
- #state { background: #f5f7fa; border-radius: 8px; padding: .3rem 1rem; margin-top: 1rem; }
- #state p { margin: .7rem 0; }
- .ok { color: #1d6b39 } .bad { color: #a3322a }
- code { background: #e7ebf0; padding: 1px 5px; border-radius: 4px; font-size: 12.5px }
-</style>
-<h1><img src="../icons/icon-48.png" alt="" width="22" height="22" style="vertical-align:-4px;border-radius:5px"> Bento Tray</h1>
-<p class="sub">
- Grant the folder your decks live in, once. After that, ⌘S on a deck you opened
- by double-clicking writes straight back to the file — no destination prompt.
-</p>
-<p><button id="renew" hidden>Renew access to this folder</button>
- <button id="pick">Choose your decks folder…</button> <button id="check">Check</button></p>
-<div id="state">…</div>
-<script type="module" src="options.js"></script>
diff --git a/tray/webext/src/options.js b/tray/webext/src/options.js
deleted file mode 100644
index ff985048..00000000
--- a/tray/webext/src/options.js
+++ /dev/null
@@ -1,91 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2026 The Bento authors
-//
-// Granting happens here and nowhere else: `showDirectoryPicker` needs a user
-// gesture, and a save is the wrong moment to discover there isn't one. The
-// service worker only ever reads the grant it finds.
-//
-// The popup and this page read the SAME status module, so they cannot tell the
-// user different stories about whether a save will land.
-
-import { getGrant, putGrant, status } from './status.js'
-
-const el = document.getElementById('state')
-const renewB = document.getElementById('renew')
-const esc = (s) => String(s).replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c]))
-
-async function report() {
- const s = await status()
- const lines = []
-
- if (s.files === false) {
- lines.push('<b class="bad">Local file access is off.</b> Open <code>chrome://extensions</code>, ' +
- 'find <b>Bento Tray</b>, and turn on <b>Allow access to file URLs</b>. ' +
- 'No extension can enable this for you, and nothing works until it is on.')
- } else if (s.files === null) {
- lines.push('<b>Local file access: unknown.</b> This browser will not report it. ' +
- 'If saves still prompt for a destination, check <b>Allow access to file URLs</b> ' +
- 'on this extension in <code>chrome://extensions</code>.')
- } else {
- lines.push('<b class="ok">Local file access is on.</b>')
- }
-
- if (!s.folder) {
- lines.push('<b>No folder granted yet.</b> Choose the folder your decks live in.')
- } else if (s.permission === 'granted') {
- // Do not promise in-place saving while file access is off — that promise is
- // false, and printing it under "nothing works until it is on" is worse than
- // saying nothing.
- lines.push(s.files === false
- ? `<b>Folder: ${esc(s.folder)}</b> — ready, but nothing saves in place until file access is on.`
- : `<b class="ok">Folder: ${esc(s.folder)}</b> — decks in here save in place, with no dialog.`)
- } else {
- // The HANDLE is still here — that is how we know the folder's name. Only
- // the permission lapsed, and Chrome takes that back with one confirmation
- // on the handle we already hold. Sending people back through
- // showDirectoryPicker made them re-find the folder every time, which is a
- // filesystem browse to answer a yes/no question.
- lines.push(`<b class="bad">Folder: ${esc(s.folder)} — needs renewing.</b> ` +
- 'Chrome drops the permission when the extension restarts. ' +
- '<b>Renew</b> restores it in one click — you do not have to find the folder again.')
- }
- renewB.hidden = !(s.folder && s.permission !== 'granted')
-
- el.innerHTML = lines.map((l) => `<p>${l}</p>`).join('')
-}
-
-document.getElementById('pick').onclick = async () => {
- try {
- const dir = await window.showDirectoryPicker({ mode: 'readwrite' })
- await dir.requestPermission({ mode: 'readwrite' })
- await putGrant(dir)
- await report()
- } catch (e) {
- el.innerHTML = `<p><b class="bad">${esc(e.name)}</b>: ${esc(e.message)}</p>`
- }
-}
-/**
- * Take the permission back on the folder we already hold.
- *
- * `requestPermission` needs a user gesture, which is why this is a button and
- * not something `report()` does on load — and why the service worker must never
- * attempt it (`background.js resolve` queries only). A click here is the
- * gesture; Chrome shows one Allow/Block confirmation naming the folder.
- *
- * The handle is re-put afterwards for the same reason it is stored at all: the
- * grant that matters is the one the service worker reads, and re-writing it is
- * cheap insurance against a handle that has been replaced rather than renewed.
- */
-renewB.onclick = async () => {
- try {
- const dir = await getGrant()
- if (!dir) return report() // nothing to renew — the pick button is the answer
- const perm = await dir.requestPermission({ mode: 'readwrite' })
- if (perm === 'granted') await putGrant(dir)
- await report()
- } catch (e) {
- el.innerHTML = `<p><b class="bad">${esc(e.name)}</b>: ${esc(e.message)}</p>`
- }
-}
-document.getElementById('check').onclick = report
-void report()
diff --git a/tray/webext/src/page-bridge.js b/tray/webext/src/page-bridge.js
index 6ebc617d..1177ef29 100644
--- a/tray/webext/src/page-bridge.js
+++ b/tray/webext/src/page-bridge.js
@@ -90,8 +90,28 @@
*/
const ID_SINCE = [1, 0, 15]
+ /**
+ * Which Bento runtime this document carries.
+ *
+ * TWO SOURCES, and both are needed. `__bentoRuntime` is announced by the
+ * kernel's `configureApp`, so every app has it automatically — that is the
+ * one to prefer. `window.bento.updates.version` is assembled by each app by
+ * hand, and is all that already-shipped documents have.
+ *
+ * The hand-assembled one is exactly why this changed: bento/dash never
+ * included `updates`, so every ⌘S in Dash fell through to a destination
+ * prompt even with a folder granted, and nothing said why. Reading both keeps
+ * every shipped Slides and Spaces document working while Dash — and whatever
+ * comes next — is fixed at the source.
+ */
+ const runtimeVersion = () => {
+ const announced = window.__bentoRuntime
+ if (typeof announced === 'string') return announced
+ return window.bento?.updates?.version
+ }
+
const runtimeAtLeast = (min) => {
- const v = window.bento?.updates?.version
+ const v = runtimeVersion()
if (typeof v !== 'string') return false // no runtime yet, or too old to say
const parts = v.split('.').map((n) => parseInt(n, 10))
if (parts.some(Number.isNaN)) return false
diff --git a/tray/webext/src/panel.html b/tray/webext/src/panel.html
new file mode 100644
index 00000000..cb3944a7
--- /dev/null
+++ b/tray/webext/src/panel.html
@@ -0,0 +1,109 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>bento/tray</title>
+<link rel="icon" href="../icons/icon.svg">
+<link rel="stylesheet" href="ui.css">
+<style>
+ /* Page-specific layout only; the palette and controls come from ui.css.
+ *
+ * THIS WAS A POPUP, and a popup was the wrong container for it. Its job is
+ * switching documents while you are working IN one — and a popup dies the
+ * moment it loses focus, which is the moment you click into the thing you
+ * were switching to. A side panel stays beside the document. Same markup,
+ * same code; the container is what changed.
+ *
+ * So the width is no longer fixed at 340px: a side panel is resizable, and
+ * the list has to hold at any width the user drags it to. */
+
+ body { min-width: 260px; height: 100vh; display: flex; flex-direction: column }
+ header { display: flex; align-items: center; gap: 8px; padding: 10px 14px; flex: none }
+ header .count { color: var(--dim); font-size: 12px; font-variant-numeric: tabular-nums;
+ flex: none }
+ .search { flex: 1; position: relative; min-width: 0 }
+ .search input { width: 100%; padding: 5px 9px; padding-inline-start: 27px; font-size: 13px }
+ .search .mag { position: absolute; inset-inline-start: 9px; top: 50%; transform: translateY(-50%);
+ color: var(--dim); font-size: 12px; pointer-events: none }
+
+ /* --- the documents, which are the point --- */
+ /* Grows to whatever height the panel has, rather than a popup's fixed cap. */
+ .docs { flex: 1; overflow-y: auto; padding: 0 8px; min-height: 0 }
+ .doc { display: flex; gap: 10px; align-items: center; width: 100%; text-align: start;
+ padding: 7px 6px; border: 0; background: none; border-radius: 8px; cursor: pointer;
+ font: inherit; color: inherit }
+ .doc:hover { background: var(--hover) }
+ .doc:disabled { cursor: default }
+ .doc:disabled .thumb { border-style: dashed }
+ .doc:disabled .meta b { opacity: .75 }
+
+ .thumb { width: 56px; height: 32px; border-radius: 4px; border: 1px solid var(--line);
+ background: var(--hover); flex: none; overflow: hidden; position: relative }
+ .thumb iframe { width: 224px; height: 128px; border: 0; transform: scale(.25);
+ transform-origin: 0 0; position: absolute; inset-inline-start: 0; top: 0; pointer-events: none }
+ .thumb .lock, .thumb .blank { display: grid; place-items: center; height: 100%;
+ color: var(--dim) }
+ .thumb .lock { font-size: 14px }
+ .thumb .blank { font-size: 15px; line-height: 1 }
+
+ .meta { flex: 1; min-width: 0 }
+ .meta b { display: block; font-weight: 600; white-space: nowrap; overflow: hidden;
+ text-overflow: ellipsis }
+ .meta span { color: var(--dim); font-size: 12px; white-space: nowrap; overflow: hidden;
+ text-overflow: ellipsis; display: block }
+
+ .empty { padding: 6px 14px 12px; color: var(--dim); font-size: 12.5px }
+
+ /* --- everything below is plumbing, and looks like it --- */
+ footer { border-top: 1px solid var(--line); padding: 9px 14px 12px; margin-top: 6px;
+ flex: none }
+ .status { display: flex; gap: 8px; align-items: center; color: var(--dim); font-size: 12px }
+ .status .grow { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis;
+ white-space: nowrap }
+ footer .btn:not(.link) { width: 100%; margin-top: 8px }
+ #prime { margin-top: 9px }
+</style>
+
+<!-- No logo and no name here. Chrome draws its OWN side-panel header with the
+ extension's icon and name directly above this document, so a second one is
+ the same words twice — which is exactly how it looked. The space goes to
+ the thing a switcher actually needs. -->
+<header>
+ <div class="search">
+ <span class="mag">⌕</span>
+ <input id="q" type="search" data-i18n-placeholder="searchDocs" autocomplete="off">
+ </div>
+ <span class="count" id="count"></span>
+</header>
+
+<div class="docs" id="docs"></div>
+<div class="empty" id="empty" hidden></div>
+
+<footer>
+ <div class="status">
+ <span class="dot" id="dot"></span>
+ <span class="grow" id="statusText"></span>
+ <button class="btn link" id="browse" data-i18n="browseAll"></button>
+ <button class="btn link" id="open" data-i18n="navSettings"></button>
+ </div>
+
+ <!-- POSITION, not Chrome's words.
+ This used to reproduce Chrome's three button labels so the highlighted
+ one matched what the user was about to see. That works in English and is
+ a liability in twenty-nine languages: the labels must match Chrome's own
+ UI exactly, nothing here can verify that they do, and a wrong one points
+ confidently at a button that does not exist.
+ The dialog's ORDER is the same in every language, so the drawing shows
+ three pills with the middle one marked and says what it does rather than
+ what it is called. Unverifiable in no language. -->
+ <div class="prime" id="prime" hidden>
+ <p data-i18n="primeIntro"></p>
+ <div class="opt"></div>
+ <div class="opt pick" data-i18n="primeMiddle"></div>
+ <div class="opt"></div>
+ <p class="primeNote" data-i18n-html="primeNote"></p>
+ </div>
+
+ <button class="btn primary" id="renew" data-i18n="reconnectFolders" hidden></button>
+ <button class="btn" id="new" data-i18n="newDocument"></button>
+</footer>
+
+<script type="module" src="panel.js"></script>
diff --git a/tray/webext/src/panel.js b/tray/webext/src/panel.js
new file mode 100644
index 00000000..49f135ee
--- /dev/null
+++ b/tray/webext/src/panel.js
@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+//
+// The tray: your documents first, plumbing at the bottom.
+//
+// This was a permissions panel — "local file access is on, folder: documents" —
+// which is true and useless. tray/ios is a document browser: you see your
+// documents and tap one. Same shape here. Permission state still has to be
+// visible, because both of its failures are silent, but it belongs in a strip
+// that stays quiet while things work.
+
+import { getGrants, putGrants, status, setLapsedBadge } from './status.js'
+import { t, localize } from './i18n.js'
+import { listDocuments, describe, newDocument } from './library.js'
+
+const $ = (id) => document.getElementById(id)
+const esc = (s) => String(s).replace(/[&<>"]/g, (c) => (
+ { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]))
+
+const ago = (ms) => {
+ const m = Math.round((Date.now() - ms) / 60000)
+ if (m < 1) return 'just now'
+ if (m < 60) return `${m}m ago`
+ const h = Math.round(m / 60)
+ if (h < 24) return `${h}h ago`
+ const d = Math.round(h / 24)
+ return d < 30 ? `${d}d ago` : new Date(ms).toLocaleDateString()
+}
+
+// ---------------------------------------------------------------- documents
+/**
+ * Render names FIRST, then fill in titles and thumbnails as they arrive.
+ *
+ * The list has to appear immediately. Reading a document for its title is cheap
+ * (a 300KB head), but its preview sits past the document block — a quarter of
+ * the way into a 900KB file — so a folder of twenty decks is twenty megabytes.
+ * Waiting for all of that before showing anything would make the popup feel
+ * broken every time the cache is cold.
+ */
+let all = []
+
+async function renderDocs() {
+ const docs = await listDocuments()
+
+ if (!docs.length) {
+ $('count').textContent = ''
+ $('empty').hidden = false
+ $('empty').textContent = t('panelEmpty')
+ return
+ }
+
+ // Newest first: the one you want is almost always the one you just had open.
+ const withTimes = await Promise.all(docs.map(async (d) => {
+ try { return { d, modified: (await d.handle.getFile()).lastModified } } catch { return { d, modified: 0 } }
+ }))
+ withTimes.sort((a, b) => b.modified - a.modified)
+ all = withTimes
+ draw()
+}
+
+/**
+ * Draw the list, filtered by whatever is in the search box.
+ *
+ * Search matters more here than in the library: this is the switcher, opened
+ * over the document you are already working in, and the whole interaction is
+ * "the other one, quickly". Matches the TITLE once it is known and the file
+ * name always — a row whose thumbnail has not loaded yet is still findable by
+ * what it is called on disk.
+ */
+function draw() {
+ const q = ($('q').value || '').trim().toLowerCase()
+ const withTimes = q
+ ? all.filter(({ d }) => (d.title ?? d.base).toLowerCase().includes(q)
+ || d.base.toLowerCase().includes(q) || d.folder.toLowerCase().includes(q)
+ || (d.text ?? '').toLowerCase().includes(q))
+ : all
+
+ $('count').textContent = q
+ ? `${withTimes.length} of ${all.length}`
+ : `${all.length} document${all.length === 1 ? '' : 's'}`
+ $('empty').hidden = withTimes.length > 0
+ if (!withTimes.length) $('empty').textContent = t('noMatches', $('q').value.trim())
+
+ const list = $('docs')
+ list.innerHTML = ''
+ // Folders we can list but not yet open. A dim row with a tooltip is not an
+ // explanation — nobody hovers a thing that looks broken — so if any exist,
+ // the list says once, in plain words, what unlocks them.
+ const unplaced = new Set()
+ for (const { d, modified } of withTimes) {
+ const row = document.createElement('button')
+ row.className = 'doc'
+ // A document whose folder has never taught us its absolute path can be
+ // listed but not opened — a directory handle has no path, and the prefix is
+ // only learned when a document from that folder is saved. Say so on the row
+ // rather than having a click do nothing.
+ if (!d.path) {
+ row.disabled = true
+ row.title = t('rowUnplacedTip', d.folder)
+ unplaced.add(d.folder)
+ }
+ row.innerHTML =
+ `<span class="thumb" data-thumb></span>` +
+ `<span class="meta"><b>${esc(d.base)}</b>` +
+ `<span>${esc(d.folder)} · ${esc(ago(modified))}</span></span>`
+ row.addEventListener('click', () => {
+ if (!d.path) return
+ chrome.tabs.create({ url: `file://${d.path.split('/').map(encodeURIComponent).join('/')}` })
+ })
+ list.appendChild(row)
+
+ // Lazily, one at a time, so a cold cache does not read every document at
+ // once and stall the popup it is decorating.
+ void (async () => {
+ try {
+ // Memoised on the descriptor, not just in the IndexedDB cache: typing
+ // in the search box redraws every row, and rebuilding a thumbnail
+ // iframe per keystroke flickers even when the read behind it is free.
+ const meta = d.meta ?? (d.meta = await describe(d))
+ d.text = meta.text
+ row.querySelector('b').textContent = meta.title
+ const thumb = row.querySelector('[data-thumb]')
+ if (meta.encrypted) {
+ thumb.innerHTML = `<span class="lock" title="${t('encrypted')}">🔒</span>`
+ } else if (meta.preview) {
+ // The preview block scales itself to whatever viewport it lands in —
+ // that is what it was written for — so a fixed-size sandboxed frame
+ // is all it needs. `sandbox` with no allow-scripts: this is somebody
+ // else's document and it renders inert.
+ const f = document.createElement('iframe')
+ f.setAttribute('sandbox', '')
+ f.srcdoc = meta.preview
+ thumb.appendChild(f)
+ } else {
+ // No preview and not encrypted: a document that has never been saved,
+ // which is exactly what "+ New document" just made. A page glyph says
+ // "nothing rendered yet"; blank white says "this is broken".
+ thumb.innerHTML = `<span class="blank" title="${t('notSavedYet')}">▤</span>`
+ }
+ } catch { /* a row without a picture is still a row */ }
+ })()
+ }
+
+ if (unplaced.size) {
+ const note = $('empty')
+ note.hidden = false
+ const names = [...unplaced]
+ // Point at the one-click fix, not at Finder. The full page can ask Chrome
+ // where these folders are (see home.js locateFolders); 340px is not the
+ // place to explain a permission request, so the popup sends people there.
+ note.innerHTML = t('panelUnplaced',
+ esc(names.slice(0, 2).join('</b>, <b>')),
+ names.length > 2 ? t('andMore', names.length - 2) : '')
+ }
+}
+
+// ------------------------------------------------------------------ plumbing
+async function renderStatus() {
+ const s = await status()
+ const lapsed = s.folders.some((f) => f.permission !== 'granted')
+ const dot = $('dot')
+ const text = $('statusText')
+
+ if (s.files === false) {
+ dot.className = 'dot bad'
+ text.innerHTML = `<span class="warn">${t('fileAccessOffShort')}</span>`
+ } else if (!s.folders.length) {
+ dot.className = 'dot meh'
+ text.textContent = t('noFoldersYet')
+ } else if (lapsed) {
+ dot.className = 'dot bad'
+ text.innerHTML = `<span class="warn">${
+ t('foldersNeedReconnect', s.folders.filter((f) => f.permission !== 'granted').length)}</span>`
+ } else {
+ dot.className = 'dot ok'
+ const n = s.folders.length
+ text.textContent = t(n === 1 ? 'statusOneFolder' : 'statusFolders', n)
+ }
+
+ $('renew').hidden = !lapsed
+ // Prime BEFORE the prompt, never after. "Allow on every visit" is offered
+ // only on Chrome's restore dialog, that dialog cannot be summoned on demand,
+ // and its three near-identical options say nothing about what they cost. So
+ // the one thing worth doing is making sure the user recognises the middle
+ // button before they see it.
+ $('prime').hidden = !lapsed
+ return s
+}
+
+$('q').addEventListener('input', draw)
+// Escape clears rather than closing: a side panel that vanished on Escape would
+// take away the thing you opened to use.
+$('q').addEventListener('keydown', (e) => {
+ if (e.key === 'Escape' && $('q').value) { e.stopPropagation(); $('q').value = ''; draw() }
+})
+
+$('renew').addEventListener('click', async () => {
+ const btn = $('renew')
+ btn.disabled = true
+ const dirs = await getGrants()
+ let ok = 0
+ // ONE PROMPT PER CLICK, and stop at the first refusal. Chromium embargoes a
+ // permission after kDefaultDismissalsBeforeBlock = 3 dismissals for
+ // kDefaultEmbargoDays = 7, and FILE_SYSTEM_ACCESS_RESTORE_PERMISSION is on
+ // that list. Those counts never reset — not on a grant, not over time — so
+ // the budget is per-origin and lifetime. This loop used to raise a prompt per
+ // folder, spending two of three on one impatient click.
+ for (const dir of dirs) {
+ try {
+ if (await dir.queryPermission({ mode: 'readwrite' }) === 'granted') { ok++; continue }
+ if (await dir.requestPermission({ mode: 'readwrite' }) !== 'granted') break
+ ok++
+ } catch { break }
+ }
+ if (ok) await putGrants(dirs)
+ await setLapsedBadge()
+
+ if (!ok) {
+ // A silent refusal is "not yet", not "never": Chrome only offers the
+ // restore prompt while the grant is dormant-and-eligible, so it can be
+ // unavailable for a session or two and then return by itself.
+ $('statusText').innerHTML = `<span class="warn">${t('renewNotOffered')}</span>`
+ $('prime').hidden = true
+ btn.textContent = t('renewTryAfterRestart')
+ return
+ }
+ location.reload()
+})
+
+$('new').addEventListener('click', async () => {
+ const btn = $('new')
+ const grants = await getGrants()
+ if (!grants.length) { chrome.runtime.openOptionsPage(); return }
+ btn.disabled = true
+ btn.textContent = t('fetchingLatest')
+ try {
+ // Into the first granted folder. Choosing between folders is a dialog this
+ // popup does not need: the common case is one folder, and a document in the
+ // wrong place is a drag away.
+ const made = await newDocument(grants[0])
+ btn.textContent = t('created', made.base)
+ await renderDocs()
+ btn.disabled = false
+ btn.textContent = t('newDocument')
+ } catch (e) {
+ btn.disabled = false
+ btn.textContent = t('newDocument')
+ $('statusText').innerHTML = `<span class="warn">${esc(e.message)}</span>`
+ }
+})
+
+// The popup stays a launcher — "open the thing I just had". Browsing wants
+// folders, search and a thumbnail big enough to recognise a deck by, none of
+// which fit in 340px that closes when it loses focus. So the page is a page,
+// and this is the door to it rather than a second copy of it.
+$('browse').addEventListener('click', () => {
+ chrome.tabs.create({ url: chrome.runtime.getURL('src/home.html') })
+})
+
+$('open').addEventListener('click', () => {
+ chrome.runtime.openOptionsPage()
+})
+
+localize()
+await renderStatus()
+await renderDocs()
diff --git a/tray/webext/src/popup.html b/tray/webext/src/popup.html
deleted file mode 100644
index 475f7cf0..00000000
--- a/tray/webext/src/popup.html
+++ /dev/null
@@ -1,25 +0,0 @@
-<!doctype html>
-<meta charset="utf-8">
-<title>Bento Tray</title>
-<style>
- body { font: 13.5px/1.5 -apple-system, system-ui, sans-serif; color: #1e2a3a; margin: 0; width: 290px; }
- header { display: flex; align-items: center; gap: 8px; padding: 12px 14px 8px; }
- header img { width: 20px; height: 20px; border-radius: 5px; }
- header b { font-size: 14px; }
- .rows { padding: 0 14px 4px; }
- .row { display: flex; gap: 8px; align-items: flex-start; padding: 7px 0; border-top: 1px solid #eceff3; }
- .row:first-child { border-top: 0; }
- .dot { width: 8px; height: 8px; border-radius: 50%; margin-top: 5px; flex: none; }
- .ok { background: #2e9e5b } .bad { background: #c2453b } .meh { background: #c9a227 }
- .t { flex: 1 }
- .t b { display: block; font-weight: 600 }
- .t span { color: #6b7a8d; font-size: 12.5px }
- footer { padding: 10px 14px 13px; }
- button { font: inherit; width: 100%; padding: 7px 10px; border: 1px solid #c8d0dc; border-radius: 8px; background: #fff; cursor: pointer; }
- button:hover { background: #f5f7fa }
- code { background: #eef1f5; padding: 1px 4px; border-radius: 4px; font-size: 12px }
-</style>
-<header><img src="../icons/icon-48.png" alt=""><b>Bento Tray</b></header>
-<div class="rows" id="rows"></div>
-<footer><button id="open">Settings…</button></footer>
-<script type="module" src="popup.js"></script>
diff --git a/tray/webext/src/popup.js b/tray/webext/src/popup.js
deleted file mode 100644
index 74857d2f..00000000
--- a/tray/webext/src/popup.js
+++ /dev/null
@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2026 The Bento authors
-//
-// The toolbar popup: says whether a save will land in place, BEFORE one is
-// attempted. Both preconditions fail silently otherwise — a lapsed folder grant
-// and a file-URL permission nothing can request — and a user who cannot see
-// them reads "the extension is broken".
-
-import { status } from './status.js'
-
-const esc = (s) => String(s).replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c]))
-
-const row = (state, title, detail) =>
- `<div class="row"><div class="dot ${state}"></div><div class="t"><b>${esc(title)}</b><span>${detail}</span></div></div>`
-
-const s = await status()
-
-const files = s.files === true
- ? row('ok', 'Local files', 'This extension may read pages opened from disk.')
- : s.files === false
- ? row('bad', 'Local files — off',
- 'Turn on <b>Allow access to file URLs</b> on this extension’s card in <code>chrome://extensions</code>. Nothing works without it, and no extension can turn it on for you.')
- : row('meh', 'Local files — unknown',
- 'This browser will not say. If saves still prompt, check <b>Allow access to file URLs</b>.')
-
-// The folder row must not promise in-place saving while the OTHER precondition
-// is failing. Seeing "decks in here save in place, with no dialog" directly
-// under "nothing works until file access is on" is two green-ish signals
-// contradicting each other, and the reassuring one is the false one.
-const folder = s.permission === 'granted'
- ? row(s.files === false ? 'meh' : 'ok', `Folder: ${esc(s.folder)}`,
- s.files === false
- ? 'Ready, but nothing saves in place until local file access is on.'
- : 'Decks in here save in place, with no dialog.')
- : s.folder
- ? row('bad', `Folder: ${esc(s.folder)} — needs renewing`,
- 'Chrome drops the permission when the extension restarts. <b>Renew</b> in Settings restores it in one click — the folder is still remembered.')
- : row('meh', 'No folder yet', 'Choose the folder your decks live in, once.')
-
-document.getElementById('rows').innerHTML = files + folder
-document.getElementById('open').addEventListener('click', () => {
- chrome.runtime.openOptionsPage()
- window.close()
-})
diff --git a/tray/webext/src/relay.js b/tray/webext/src/relay.js
index 22567cc1..4a043575 100644
--- a/tray/webext/src/relay.js
+++ b/tray/webext/src/relay.js
@@ -15,6 +15,30 @@
const CH = '__bento_tray__'
+/**
+ * Say hello, once, on load.
+ *
+ * This is the ONLY thing here that the page did not ask for, and it exists to
+ * fix a chicken-and-egg. The tray lists documents by walking granted folders,
+ * but a `FileSystemDirectoryHandle` has no path, so it cannot turn one into a
+ * URL to open. The path is learned by subtracting a file's route-from-the-grant
+ * from its absolute `sender.url` — and that only happened during a SAVE. So on
+ * a fresh install every row was listed and none could be opened, which is
+ * exactly as useful as no list at all.
+ *
+ * Opening a document is the natural moment to learn where its folder is. One
+ * document opened teaches the prefix for its whole folder, and every other
+ * document in there becomes openable from the tray.
+ *
+ * It sends no payload — the extension reads `sender.url`, which the browser
+ * stamps and this page cannot forge — and ignores the answer. A page that
+ * cannot be placed inside a grant simply is not one, and nothing is written
+ * either way.
+ */
+chrome.runtime.sendMessage({ op: 'hello' }).catch(() => {
+ /* worker asleep, extension reloading, page outside every grant — all fine */
+})
+
window.addEventListener('message', async (ev) => {
const d = ev.data
// Same-window only: `ev.source !== window` rejects anything posted in from a
diff --git a/tray/webext/src/route.js b/tray/webext/src/route.js
new file mode 100644
index 00000000..a268847e
--- /dev/null
+++ b/tray/webext/src/route.js
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+//
+// Placing an absolute path inside a granted folder.
+//
+// Extracted from background.js so the SERVICE WORKER and the PAGES can both do
+// it. The worker places a document that is saving; the home page places paths
+// found in history to learn where folders live. Both must agree, and both must
+// verify rather than guess — a wrong answer here writes to, or opens, the wrong
+// file. Importing background.js into a page instead would have registered a
+// second `onMessage` listener in that page, which is its own bug.
+
+/**
+ * The file this message is about, according to the BROWSER.
+ *
+ * Not according to the page: a content script's `sender.url` is stamped by
+ * Chrome. Only `file:` is accepted — the bridge exists for local documents, and
+ * an http page has no business claiming one.
+ */
+export function pathFromSender(sender) {
+ try {
+ const u = new URL(sender?.url ?? '')
+ if (u.protocol !== 'file:') return null
+ return decodeURIComponent(u.pathname)
+ } catch {
+ return null
+ }
+}
+
+/**
+ * Find a path inside one grant WITHOUT searching for it.
+ *
+ * THE INSIGHT. A `FileSystemDirectoryHandle` knows its own name but not its
+ * path, so a grant and an absolute path cannot be compared directly — which is
+ * why this used to walk the tree looking for a matching filename. But a
+ * directory's NAME must appear in the path of every file inside it. So the name
+ * locates the split point, and everything after it is the route: one
+ * `getDirectoryHandle` per segment, then `getFileHandle`.
+ *
+ * O(path depth), with no scanning at all. Three things follow:
+ *
+ * · a grant can be ANY size — a home directory costs the same as a decks
+ * folder, because nothing is enumerated
+ * · several grants are cheap to try, since each attempt is a few lookups
+ * · two documents sharing a filename stop being ambiguous. The old walk found
+ * both and declined; the route reaches exactly one, because only one path
+ * leads to it.
+ *
+ * It is checked, not guessed. A wrong split point fails at the first missing
+ * segment, and callers re-verify the file it lands on regardless.
+ *
+ * A folder name can repeat in a path (`/Users/andy/Decks/Decks/Q3.bento.html`),
+ * so every split point is tried; the caller decides what more than one hit
+ * means.
+ */
+export async function locateIn(dir, path) {
+ const name = dir.name
+ const hits = []
+ for (let i = path.indexOf(`/${name}/`); i !== -1; i = path.indexOf(`/${name}/`, i + 1)) {
+ const rel = path.slice(i + name.length + 2).split('/').filter(Boolean)
+ if (!rel.length) continue
+ try {
+ let cur = dir
+ for (const seg of rel.slice(0, -1)) cur = await cur.getDirectoryHandle(seg)
+ const file = await cur.getFileHandle(rel[rel.length - 1])
+ hits.push({ file, rel })
+ } catch {
+ // Not this split point — a segment that does not exist is an answer, not
+ // an error. Keep trying the others.
+ }
+ }
+ return hits
+}
+
+/**
+ * Where a granted folder lives, given an absolute path to something inside it.
+ *
+ * Returns null unless the path can be PROVEN to be in this grant: the route has
+ * to resolve, and `dir.resolve()` on what it lands on has to agree with the
+ * path's own tail. That second check is the one that matters — a file merely
+ * sharing a name is not the same file, and treating it as one has destroyed a
+ * document before (see background.js `resolve`).
+ */
+export async function prefixFor(dir, path) {
+ for (const { file } of await locateIn(dir, path)) {
+ const rel = await dir.resolve(file)
+ if (!rel || !rel.length) continue
+ const suffix = `/${rel.join('/')}`
+ if (path.endsWith(suffix)) return path.slice(0, -suffix.length)
+ }
+ return null
+}
diff --git a/tray/webext/src/status.js b/tray/webext/src/status.js
index 579edd11..33230d8f 100644
--- a/tray/webext/src/status.js
+++ b/tray/webext/src/status.js
@@ -3,37 +3,35 @@
//
// What the extension can and cannot do right now, in one place.
//
-// Two things have to be true before a deck saves in place, and BOTH fail
-// silently by nature: a folder grant that lapses whenever the service worker
-// restarts, and a file-URL permission that no manifest can request. Neither is
-// visible until a save is attempted, which is the worst possible moment to
-// discover them — so the popup and the options page read this and say so first.
+// Two things have to be true before a document saves in place, and BOTH fail
+// silently by nature: a folder grant that Chrome drops on a browser restart,
+// and a file-URL permission that no manifest can request. Neither is visible
+// until a save is attempted, which is the worst possible moment to discover
+// them — so every surface reads this and says so first.
-const DB = 'bento-tray'
-const STORE = 'grant'
+import { GRANT, get, put } from './db.js'
+import { t } from './i18n.js'
-const open = () => new Promise((res, rej) => {
- const r = indexedDB.open(DB, 1)
- r.onupgradeneeded = () => r.result.createObjectStore(STORE)
- r.onsuccess = () => res(r.result); r.onerror = () => rej(r.error)
-})
-
-export const getGrant = async () => {
- const d = await open()
- return new Promise((res, rej) => {
- const t = d.transaction(STORE, 'readonly')
- const q = t.objectStore(STORE).get('dir')
- q.onsuccess = () => res(q.result ?? null); q.onerror = () => rej(q.error)
- })
+/**
+ * Every granted folder, oldest first.
+ *
+ * `dirs` is the list; `dir` is the single-grant key this shipped with, still
+ * read so an upgrade does not silently drop the folder someone already granted.
+ * Both halves of the extension reach the store through db.js, so there is no
+ * longer a second copy of these key names to drift from.
+ */
+export const getGrants = async () => {
+ const list = await get(GRANT, 'dirs')
+ if (Array.isArray(list) && list.length) return list
+ const one = await get(GRANT, 'dir')
+ return one ? [one] : []
}
-export const putGrant = async (v) => {
- const d = await open()
- return new Promise((res, rej) => {
- const t = d.transaction(STORE, 'readwrite')
- t.objectStore(STORE).put(v, 'dir')
- t.oncomplete = res; t.onerror = () => rej(t.error)
- })
+/** Replace the list. `dir` is cleared once a list exists, so the legacy key
+ * cannot resurrect a folder the user has since removed. */
+export const putGrants = async (list) => {
+ await put(GRANT, 'dirs', list)
+ await put(GRANT, 'dir', null)
}
/**
@@ -57,19 +55,134 @@ export async function fileAccess() {
}
}
-/** Everything the UI needs: {files, folder, permission, ready}. */
+/**
+ * Mark the toolbar icon when a folder needs reconnecting.
+ *
+ * A lapsed grant used to be invisible until a save fell back to a picker, which
+ * is the worst moment to learn about it: the interruption has already happened,
+ * and nothing on screen connects it to the extension. The badge moves that
+ * discovery BEFORE the save, onto the icon the popup hangs off — the same place
+ * the fix is.
+ *
+ * Best effort. `chrome.action` is absent in the test rig and in any page that
+ * imports this module for its data only, and a badge that cannot be set is not
+ * worth failing a save over.
+ */
+export async function setLapsedBadge() {
+ try {
+ if (typeof chrome === 'undefined' || !chrome.action?.setBadgeText) return false
+ const dirs = await getGrants()
+ const perms = await Promise.all(
+ dirs.map((d) => d.queryPermission({ mode: 'readwrite' }).catch(() => 'unreadable')),
+ )
+ // Only when something WAS granted and has lapsed. A user who has never
+ // picked a folder is not behind on anything, and badging them would be
+ // nagging rather than reporting.
+ const stale = dirs.length > 0 && perms.some((p) => p !== 'granted')
+ await chrome.action.setBadgeText({ text: stale ? '!' : '' })
+ if (stale) {
+ await chrome.action.setBadgeBackgroundColor?.({ color: '#C2453B' })
+ await chrome.action.setTitle?.({ title: t('actionTitleLapsed') })
+ } else {
+ await chrome.action.setTitle?.({ title: t('actionTitle') })
+ }
+ return stale
+ } catch {
+ /* never let the badge break a save */
+ return false
+ }
+}
+
+const NOTIFIED = 'lapsed-notified'
+
+/**
+ * Tell the user ONCE per browser session that a folder needs reconnecting.
+ *
+ * The badge is passive — it reports to anyone who looks at the toolbar, and
+ * nobody looks at the toolbar. A lapse is otherwise discovered when a save
+ * falls back to a picker, which is both too late and unattributable.
+ *
+ * ONCE, though. The worker re-runs this after every message, and a save is
+ * many messages; a notification per message would be unusable, and one per
+ * save not much better. `chrome.storage.session` is exactly the right
+ * lifetime — it clears when the browser restarts, which is also when a grant
+ * lapses, so the next session gets exactly one fresh telling.
+ *
+ * Cleared as soon as the grant is healthy again, so a lapse later in the same
+ * session is still announced.
+ */
+export async function notifyIfLapsed(stale) {
+ try {
+ if (typeof chrome === 'undefined' || !chrome.notifications?.create) return
+ const session = chrome.storage?.session
+ const seen = session ? (await session.get(NOTIFIED))[NOTIFIED] : false
+
+ if (!stale) {
+ if (seen) await session?.remove(NOTIFIED)
+ return
+ }
+ if (seen) return
+ await session?.set({ [NOTIFIED]: true })
+
+ await chrome.notifications.create('bento-tray-lapsed', {
+ type: 'basic',
+ iconUrl: chrome.runtime.getURL('icons/icon-128.png'),
+ title: t('notifyLapsedTitle'),
+ message: t('notifyLapsedBody'),
+ buttons: [{ title: t('reconnect') }],
+ requireInteraction: false,
+ })
+ } catch {
+ /* a notification is never worth failing a save over */
+ }
+}
+
+/**
+ * Put the reconnect button in front of the user.
+ *
+ * This used to try `chrome.action.openPopup()`. There is no popup any more —
+ * the toolbar icon opens the library, and the tray lives in a side panel — so
+ * the notification leads to the library, which carries the same reconnect
+ * affordance with room to explain it.
+ *
+ * Deliberately not `sidePanel.open()`: that must be called synchronously inside
+ * a user gesture, and this is reached from a notification click handler after
+ * an await. It would be refused, silently, which is the worst of both.
+ */
+export async function openReconnectUi() {
+ try {
+ await chrome.tabs.create({ url: chrome.runtime.getURL('src/home.html') })
+ return 'library'
+ } catch {
+ return 'none'
+ }
+}
+
+/**
+ * Everything the UI needs: {files, folders, ready}.
+ *
+ * `folders` is one row per grant — `{name, permission}` — because with more
+ * than one folder the interesting state is per-folder: a single lapsed grant
+ * must not read as "the extension is broken", and a single healthy one must not
+ * read as "everything is fine". `ready` therefore means at least one folder can
+ * be written to, which is the honest summary of "will a save land": it depends
+ * on which document.
+ */
export async function status() {
const files = await fileAccess()
- let folder = null
- let permission = 'none'
+ let folders = []
try {
- const dir = await getGrant()
- if (dir) {
- folder = dir.name
- permission = await dir.queryPermission({ mode: 'readwrite' })
- }
+ const dirs = await getGrants()
+ folders = await Promise.all(dirs.map(async (dir) => ({
+ name: dir.name,
+ permission: await dir.queryPermission({ mode: 'readwrite' }).catch(() => 'unreadable'),
+ })))
} catch {
- permission = 'unreadable'
+ folders = [{ name: '(unreadable)', permission: 'unreadable' }]
+ }
+ return {
+ files,
+ folders,
+ ready: files !== false && folders.some((f) => f.permission === 'granted'),
}
- return { files, folder, permission, ready: files !== false && permission === 'granted' }
}
diff --git a/tray/webext/src/ui.css b/tray/webext/src/ui.css
new file mode 100644
index 00000000..36cf2128
--- /dev/null
+++ b/tray/webext/src/ui.css
@@ -0,0 +1,122 @@
+/* SPDX-License-Identifier: MIT
+ * Copyright (c) 2026 The Bento authors
+ *
+ * One design system for every surface the extension has.
+ *
+ * There were three: the home page had tokens and dark mode, the popup had 21
+ * hardcoded colours and no dark mode, the options page had 16 and no dark mode.
+ * The same product in three costumes, and the popup — the surface people
+ * actually open — was the one that turned white at midnight.
+ *
+ * Tokens only below the palette. If a colour appears twice in this file it is a
+ * mistake; if it appears in a page's own <style> it is almost certainly one too.
+ */
+
+:root {
+ --bg: #f6f8fa; --panel: #fff; --ink: #17222f; --dim: #6b7a8d;
+ --line: #e4e9ef; --hover: #eef2f6; --accent: #16273e; --peach: #ff9e8a;
+ --good: #2e9e5b; --bad: #c2453b; --warn: #c9a227;
+ --on-accent: #fff; --on-good: #fff;
+ --shadow: 0 1px 2px rgba(20,35,60,.06), 0 8px 24px rgba(20,35,60,.06);
+ --lift: 0 2px 6px rgba(20,35,60,.10), 0 14px 34px rgba(20,35,60,.12);
+ --r: 9px;
+}
+@media (prefers-color-scheme: dark) {
+ :root {
+ --bg: #0f1720; --panel: #16202b; --ink: #e7edf4; --dim: #90a1b4;
+ --line: #24313f; --hover: #1d2937; --accent: #e7edf4; --peach: #ff9e8a;
+ --on-accent: #0f1720; /* --on-good stays white: it sits on green in both themes */
+ --shadow: 0 1px 2px rgba(0,0,0,.4), 0 8px 24px rgba(0,0,0,.34);
+ --lift: 0 2px 6px rgba(0,0,0,.45), 0 16px 40px rgba(0,0,0,.46);
+ }
+}
+
+* { box-sizing: border-box }
+body {
+ margin: 0; background: var(--bg); color: var(--ink);
+ font: 14px/1.55 -apple-system, system-ui, "Segoe UI", sans-serif;
+}
+
+/* --- type ---------------------------------------------------------------- */
+h1 { font-size: 19px; margin: 0; letter-spacing: -.015em }
+h2 { font-size: 15px; margin: 0 0 6px }
+.dim { color: var(--dim) }
+.warn { color: var(--bad) }
+code { background: var(--hover); padding: 1px 5px; border-radius: 4px; font-size: 12.5px }
+
+/* --- controls ------------------------------------------------------------ */
+.btn, select, input[type="search"], input[type="text"] {
+ font: inherit; padding: 7px 11px; border: 1px solid var(--line);
+ border-radius: var(--r); background: var(--panel); color: inherit;
+}
+.btn { cursor: pointer }
+.btn:hover, select:hover { background: var(--hover) }
+.btn:focus-visible, input:focus-visible, select:focus-visible,
+.card:focus-visible, .navitem:focus-visible {
+ outline: 2px solid var(--peach); outline-offset: 2px
+}
+input:focus { outline: 2px solid var(--peach); outline-offset: -1px; border-color: transparent }
+.btn.primary { background: var(--accent); border-color: var(--accent); color: var(--on-accent) }
+.btn.primary:hover { filter: brightness(1.12) }
+.btn.ghost { border-style: dashed; color: var(--dim); background: none; text-align: start }
+.btn.ghost:hover { background: var(--hover); color: var(--ink) }
+.btn.link { border: 0; background: none; color: var(--dim); padding: 0;
+ text-decoration: underline; font-size: 12px }
+.btn.link:hover { color: var(--ink); background: none }
+.btn[disabled] { opacity: .55; cursor: default }
+
+/* --- state dots ---------------------------------------------------------- */
+.dot { width: 8px; height: 8px; border-radius: 50%; flex: none; background: var(--dim) }
+.dot.ok { background: var(--good) } .dot.bad { background: var(--bad) }
+.dot.meh { background: var(--warn) }
+
+/* --- surfaces ------------------------------------------------------------ */
+.notice {
+ padding: 10px 13px; border-radius: 10px; background: var(--panel);
+ border: 1px solid var(--line); color: var(--dim); font-size: 13px;
+ box-shadow: var(--shadow);
+}
+.notice b { color: var(--ink) }
+.notice.bad { border-color: color-mix(in srgb, var(--bad) 40%, var(--line)) }
+
+.menu {
+ position: fixed; z-index: 20; background: var(--panel); border: 1px solid var(--line);
+ border-radius: 10px; box-shadow: var(--lift); padding: 5px; min-width: 176px;
+}
+.menu button {
+ display: block; width: 100%; text-align: start; border: 0; background: none;
+ color: inherit; font: inherit; padding: 6px 9px; border-radius: 7px; cursor: pointer;
+}
+.menu button:hover { background: var(--hover) }
+.menu .sep { height: 1px; background: var(--line); margin: 5px 4px }
+.menu .note { color: var(--dim); font-size: 12px; padding: 4px 9px 6px }
+
+/* Centred without naming a side. `left: 50%` + `translateX(-50%)` also centres,
+ but the translate is PHYSICAL: under RTL it pushes the same direction while
+ the anchor flips, so the toast drifts off centre. Auto margins do not care
+ which way the document runs. */
+.toast {
+ position: fixed; inset-inline: 0; bottom: 26px;
+ margin-inline: auto; width: max-content; max-width: calc(100% - 32px);
+ background: var(--accent); color: var(--on-accent); padding: 9px 15px;
+ border-radius: 999px; box-shadow: var(--lift); font-size: 13px; z-index: 30;
+}
+
+/* --- the mark ------------------------------------------------------------ */
+/* The radius lives in the art (icons/icon.svg), never in a CSS crop. */
+.mark { display: block; flex: none }
+
+/* --- Chrome's own dialog, drawn ------------------------------------------ */
+/* Its three options are near-identical pills and its wording says nothing about
+ what each one costs, so pointing at the middle one in prose does not work. */
+.prime { border: 1px solid var(--line); border-radius: 10px; padding: 9px; background: var(--panel) }
+.prime p { margin: 0 0 7px; color: var(--dim); font-size: 12.5px }
+.prime .opt {
+ border-radius: 999px; padding: 5px 9px; font-size: 12px; text-align: center;
+ background: var(--hover); color: var(--dim); margin-bottom: 5px;
+}
+.prime .opt.pick { background: var(--accent); color: var(--on-accent); font-weight: 600 }
+/* The unlabelled pills are shape, not text: they stand for "the one above" and
+ "the one below" without claiming to know what Chrome calls them. */
+.prime .opt:empty { min-height: 1.55em }
+.prime .primeNote { margin: 7px 0 0; color: var(--dim); font-size: 12px }
diff --git a/tray/webext/src/update.js b/tray/webext/src/update.js
new file mode 100644
index 00000000..122f612d
--- /dev/null
+++ b/tray/webext/src/update.js
@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2026 The Bento authors
+//
+// Telling unpacked installs that they are behind.
+//
+// THE PROBLEM. Store installs update themselves; an extension loaded unpacked
+// NEVER does. Chrome ignores `update_url` for a development install — it is
+// running from a directory on disk, and nothing is going to rewrite that
+// directory. So someone who takes the GitHub route is frozen at whatever they
+// downloaded, and will not find out from the browser.
+//
+// WHO IS ASKED. `chrome.management.getSelf()` reports `installType`, and
+// `development` means unpacked. It needs NO permission — verified in the API
+// docs, which say so explicitly — so this costs nothing on the listing. Store
+// users (`normal`) are never checked and never badged: they update silently,
+// and a notice they cannot act on is noise.
+//
+// WHAT IS SENT. A GET for a static JSON file. No identifiers, no query string,
+// no version reported upward — the comparison happens here. That is the same
+// promise the app's own update check makes ("no ids, no telemetry"), and it
+// should not be quietly weaker in the extension.
+//
+// WHAT IT DOES NOT DO. It cannot install anything. There is no mechanism for an
+// unpacked extension to update itself, and inventing one would mean downloading
+// code and asking the user to trust it — exactly the thing a reviewer would ask
+// about. It reports, links to the release, and stops.
+
+import { GRANT, get, put } from './db.js'
+
+/** Mirrors the app's release channels: /releases/<app>/manifest.json */
+const MANIFEST = 'https://bento.page/releases/tray/manifest.json'
+
+/**
+ * Where to ask. A dev override exists for the same reason the app has one
+ * (`localStorage 'bento-update-url'` in kernel/src/update.ts): until the real
+ * manifest is published there is no way to see the notice at all, and a feature
+ * that cannot be exercised before release is a feature nobody has tested.
+ *
+ * From the library page's console:
+ *
+ * const d = await indexedDB.open('bento-tray', 2)
+ * // …or simply: import('./db.js').then(m => m.put('grant','updateUrl','http://localhost:5194/tray.json'))
+ *
+ * Never read from a document or a message — only from this extension's own
+ * store, which only its own pages can write.
+ */
+const manifestUrl = async (deps) => {
+ if (deps.url) return deps.url
+ try { return (await get(GRANT, 'updateUrl')) || MANIFEST } catch { return MANIFEST }
+}
+
+/**
+ * Whether to check at all. DEFAULT ON, and switchable.
+ *
+ * On by default because an unpacked install has no other way to learn it is
+ * behind — the browser will never tell it — and because the app itself checks
+ * at launch by default (`kernel/src/update.ts`, off switch in the About
+ * dialog). The extension behaving differently would be an inconsistency with
+ * no argument behind it.
+ *
+ * Switchable because this repo has form on the other side: the v0.9.1 fix
+ * existed so the anonymous demo never phones home for someone who did not ask
+ * it to. A version check carries no identifiers and no document data, which is
+ * a different thing from a relay connection — but the audience that loads an
+ * extension unpacked from GitHub is exactly the audience entitled to say no,
+ * and a preference they can see is the difference between a courtesy and a
+ * thing done to them.
+ */
+export const autoCheckEnabled = async (deps = {}) => {
+ const read = deps.get ?? (() => get(GRANT, 'autoCheck'))
+ try {
+ return (await read()) !== false // absent means on
+ } catch {
+ // The store is unreadable — private mode, quota, a migration mid-flight.
+ // Treated as ON, matching "absent means on": a storage hiccup should not
+ // quietly switch off a feature the user never turned off. The only cost of
+ // being wrong here is one request they had asked not to make, once.
+ return true
+ }
+}
+
+export const setAutoCheck = (on) => put(GRANT, 'autoCheck', !!on)
+
+/** Numeric compare, most significant first. Returns >0 when `a` is newer. */
+export function compareVersions(a, b) {
+ const pa = String(a).split('.').map(Number)
+ const pb = String(b).split('.').map(Number)
+ for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+ const d = (pa[i] || 0) - (pb[i] || 0)
+ if (d) return d
+ }
+ return 0
+}
+
+/**
+ * Is this install one that will never update itself?
+ *
+ * Anything but `normal` is treated as "tell them": `development` is the GitHub
+ * route this exists for, and `sideload`/`admin`/`other` also arrive outside the
+ * store's update mechanism. Being unable to ask at all is treated the same way
+ * as a store install — silence — because badging on a guess is worse than
+ * missing a case.
+ */
+export async function isSelfManaged(deps = {}) {
+ const getSelf = deps.getSelf ?? (() => chrome.management.getSelf())
+ try {
+ const self = await getSelf()
+ return self?.installType !== 'normal'
+ } catch {
+ return false
+ }
+}
+
+/**
+ * Check, and remember the answer.
+ *
+ * Stored rather than returned to a caller, because the surfaces that show it —
+ * the badge, the library, settings — run in different contexts at different
+ * times, and none of them should trigger a network request of its own.
+ */
+export async function checkForUpdate(deps = {}) {
+ const net = deps.fetch ?? fetch
+ const current = deps.currentVersion ?? chrome.runtime.getManifest().version
+ const save = deps.put ?? ((v) => put(GRANT, 'update', v))
+
+ if (!(await isSelfManaged(deps))) {
+ await save(null) // a store install that was once unpacked must stop nagging
+ return null
+ }
+
+ // Asked before anything leaves the machine, and before the manual "Check now"
+ // path too — that one passes `force`, because pressing a button IS the
+ // consent the preference otherwise stands in for.
+ if (!deps.force && !(await autoCheckEnabled(deps))) return null
+
+ try {
+ const res = await net(await manifestUrl(deps), { cache: 'no-store' })
+ if (!res.ok) return null
+ const m = await res.json()
+ if (!m?.version || compareVersions(m.version, current) <= 0) {
+ await save(null)
+ return null
+ }
+ const found = {
+ version: m.version,
+ url: m.url ?? 'https://github.com/nyblnet/bento/releases',
+ // The package is byte-reproducible (scripts/pack-webext.mjs), so a
+ // published digest lets anyone confirm the zip they downloaded is the one
+ // that was built. Carried through rather than dropped, even though
+ // nothing here can verify it: the person doing the install can.
+ sha256: m.sha256 ?? null,
+ found: Date.now(),
+ }
+ await save(found)
+ return found
+ } catch {
+ // Offline, DNS, a redirect to a captive portal. Silence is right: this is
+ // a courtesy, and a broken courtesy should not look like a broken product.
+ return null
+ }
+}
+
+/** What the last check found, if anything. */
+export const pendingUpdate = () => get(GRANT, 'update')