1. Scope of this policy
This policy describes how Pointer 1.0.0 handles information when you save a pointer to selected text, pick a page element, open a saved pointer, or delete saved pointer history.
Pointer is a local browser utility. It does not provide a cloud account, synchronized bookmark service, social sharing network, analytics platform, advertising product, or remote database.
The webpages to which you create pointers remain governed by their own privacy practices. Pointer does not control the data collection performed by those websites.
2. What a text pointer stores
When the user selects text and chooses to create a pointer, Pointer stores the page URL and title, the selected quote, a limited amount of nearby prefix and suffix text, the closest preceding heading when available, and a selector candidate for the containing element.
The selected quote is normalized for whitespace and limited to 500 characters. Nearby prefix and suffix context are limited to short windows around the selection. A display label is derived from the beginning of the selected text so the pointer can be recognized in the popup.
These fields are used to distinguish the exact passage from similar passages when the user returns later. Pointer does not store the complete article or an offline copy of the page.
3. What an element pointer stores
Element pick mode lets the user choose a visible element directly on the page. Pointer stores a compact fingerprint rather than copying the entire DOM subtree.
The fingerprint may include the element tag, visible text, accessible label, role, nearby heading context, page URL, page title, and a selector candidate based on stable attributes such as id, selected data attributes, aria-label, name, or a limited structural fallback.
Visible element text stored as a quote is limited to a compact value needed for matching and labeling. Pointer does not preserve stylesheets, event handlers, scripts, images, or the full HTML of the picked element.
4. Explicit user interaction
Pointer does not crawl pages in the background. The current page is inspected only after the user invokes the extension and Chrome grants temporary activeTab access.
Text pointer creation reads the current browser selection. Element pick mode temporarily highlights the element under the pointer and captures the chosen element only when the user clicks it. Pressing Escape cancels pick mode without saving an element pointer.
Pointer does not continuously track mouse movement outside the short-lived pick interaction and does not create a history of every element a user hovered.
5. How resolution works
Opening a saved pointer creates the saved URL in a browser tab. After that page finishes loading, Pointer injects its packaged resolver and tries to identify the original target.
For a text pointer, the resolver requires the saved quote to be present and scores candidate elements using exactness and contextual signals such as the saved heading and nearby text. For an element pointer, it scores selector matches and fingerprint signals such as tag, visible text, role, and accessible label.
When a match reaches the required confidence, Pointer scrolls it into view and draws a temporary highlight. The highlight is a local overlay and does not modify the website’s stored content.
6. Conservative failure behavior
Pointer is designed to prefer a visible failure over a weak guess. If the original quote no longer exists, a shorter similar sentence is not accepted as a substitute for a text pointer.
If an element’s selector fails, the resolver may use other fingerprint signals. However, the candidate must still reach a minimum matching score before Pointer scrolls or highlights it.
When no candidate is strong enough, Pointer shows a short “could not find its target” message. The user can then create a new pointer if the page has changed.
7. Pointer history
Pointer keeps a recent local history so saved references can be reopened from the popup. Version 1.0.0 retains at most 60 items.
Adding a new pointer places it at the front of the history. If the list exceeds 60 items, the oldest items beyond the limit are removed automatically.
Each item can also be deleted explicitly from the popup. Pointer does not maintain a second hidden archive of deleted items.
8. Local storage
Pointer stores its history in chrome.storage.local, which is extension-specific storage managed by Chrome on the user’s device.
There is no Pointer server and no account-based synchronization. The packaged extension does not upload quotes, URLs, headings, selectors, or pointer history to a developer-controlled endpoint.
Operating systems or browsers may back up profile data according to the user’s own settings. That platform-level behavior is outside Pointer’s code.
9. Deletion and user control
Users can delete individual pointers from the recent list. Removing the extension or clearing its extension storage removes the local pointer history according to Chrome’s normal storage behavior.
Pointer does not silently recreate a deleted pointer from a server because there is no remote pointer database.
Users decide when to select text, when to start element pick mode, when to open a saved pointer, and when to delete a pointer.
- Create from selected text — saves the current selection and context.
- Pick an element — saves the element chosen by the user.
- Open pointer — opens the saved URL and resolves the target.
- Delete — removes the chosen local history item.
10. Chrome permissions
Pointer requests activeTab, scripting, and storage. It does not request the broad tabs permission and does not request persistent host_permissions or the
activeTab supplies temporary access to the page after the user invokes Pointer. scripting injects only the packaged picker or resolver. storage retains the recent pointer list locally.
The extension uses tab creation and lifecycle capabilities available to extensions without requesting broad access to arbitrary tab metadata.
11. Network behavior
Pointer makes no extension-initiated network requests. The package contains no remote JavaScript, external stylesheet, remote font dependency, analytics beacon, telemetry endpoint, advertising SDK, AI API, or third-party tracking library.
Opening a pointer navigates Chrome to the URL that the user previously saved. The website at that URL may make its normal network requests, just as it would if opened from a conventional bookmark.
Pointer does not proxy, mirror, cache, or upload the opened webpage through a developer service.
12. No remote code
All executable Pointer code needed for version 1.0.0 is packaged with the extension. The scripting permission is used only to execute those packaged files in eligible pages.
Pointer does not download JavaScript for execution and does not use eval or Function constructors to execute remote or stored code.
This design keeps matching behavior reviewable in the extension package and avoids introducing a remote execution dependency.
13. Third parties and data sale
Pointer does not sell, rent, trade, or broker saved pointer data. It does not share pointer history with advertisers, data brokers, analytics providers, AI providers, or marketing platforms.
There are no third-party SDKs in the packaged extension that receive saved quotes or element fingerprints. Chrome provides the extension APIs used for temporary page access and local storage.
Websites opened from a pointer may have their own third-party integrations. Those website integrations are independent of Pointer.
14. Security design
Pointer minimizes persistent access by relying on activeTab rather than an always-on permission for every website. The resolver runs only for a pointer the user chose to open.
Saved pointer records are not encrypted with a separate Pointer password. Their confidentiality therefore also depends on the security of the user’s Chrome profile, device account, and operating system.
Users should avoid creating pointers to sensitive text if other people have access to the same browser profile, because the selected quote may be visible in Pointer’s local history.
15. Private and incognito browsing
Chrome decides whether Pointer may run in incognito mode. The extension does not automatically enable itself for private windows.
If the user explicitly allows Pointer in incognito, Chrome determines how extension storage is separated or shared for that configuration. Users should consider whether they want sensitive URLs or quotes retained in extension storage before enabling it there.
Pointer does not contain code intended to bypass private-browsing isolation or correlate private browsing with regular browsing on a developer server.
16. Sensitive pages and browser restrictions
Some browser-internal pages, extension galleries, local browser surfaces, or pages restricted by Chrome cannot be scripted. Pointer may be unable to create or resolve a pointer on those surfaces.
When Chrome denies access, Pointer reports the limitation instead of attempting to bypass it. The extension does not ask the user to disable browser security protections.
Pointer also cannot guarantee that a dynamically generated site will preserve enough stable text or structure for a pointer to resolve in the future.
17. Children
Pointer is a general-purpose browser utility and is not designed specifically for children. It has no social network, behavioral advertising, account-registration flow, or developer server collecting age, name, email address, or profile information.
Because a saved pointer can contain a short excerpt of selected webpage text, guardians and managed-device administrators should decide whether storing such local references is appropriate for a particular user.
Pointer does not knowingly collect children’s personal information on a developer server because version 1.0.0 has no developer data collection server.
18. Changes to this policy
This policy describes Pointer version 1.0.0. A future version that adds synchronization, sharing, analytics, broader permissions, new captured fields, or extension-initiated network behavior will require an updated privacy description.
Editorial changes may clarify the existing behavior without changing what the extension collects or does. Material changes should be reflected in the policy published with the Chrome Web Store listing and, where appropriate, release notes.
Users who do not accept a future version’s practices can delete local pointers and uninstall the extension.
19. Contact and questions
Privacy and support questions should be sent through the developer support contact published on the Chrome Web Store listing associated with Pointer. This keeps the packaged policy independent of an unverified personal address.
When reporting a resolver problem, users should avoid sending sensitive quotes or private URLs unless they intentionally choose to disclose them for troubleshooting.
A useful report can usually identify the Pointer version, Chrome version, page type, whether the pointer was created from text or an element, and whether the target still visibly exists.
20. Operational limitations
Pointer depends on information that a webpage exposes in its current DOM and visible text. A pointer can fail after a site rewrites content, removes the target, moves information into an inaccessible frame, or generates unstable labels and structures.
The resolver is intentionally conservative, so some targets that a person would recognize may still be rejected when the stored signals are not strong enough. This is preferable to silently highlighting the wrong instruction or control.
Pointer is a reference utility rather than an archival system. It does not preserve an old copy of a webpage and cannot reconstruct content that the publisher later removes.
- Create a new pointer after a page materially changes.
- Treat a failed match as unresolved rather than as evidence that the target moved to a similar paragraph.
- Use a dedicated archival tool when an immutable historical copy is required.
21. Data flow at a glance
The data path begins with an explicit user action: temporary activeTab access lets Pointer read a selection or enter pick mode. The resulting compact reference is stored in chrome.storage.local.
When the user opens that reference, Chrome navigates to the stored URL and the packaged resolver receives only that saved pointer record so it can search the loaded page locally.
The match result is displayed as a temporary highlight or a failure message. Pointer does not send the quote, selector, page text, or match score to a developer endpoint.
22. Policy summary
Pointer stores compact local references so the user can return to a precise passage or element. The extension uses temporary page access when the user asks it to capture or resolve a target.
Pointer does not upload saved references, does not require a cloud account, does not use remote code, and does not monetize browsing data.
The user controls creation, opening, and deletion, while the resolver intentionally refuses weak matches instead of silently pointing somewhere else.