SearchXR XRDeveloper Platform Documentation

SDK 2.5.0-XRSPEC 2026.1STABLE

The XR Developer Layer.

A complete standalone specification and SDK reference for developers who want to understand, integrate and extend the XR runtime. Contracts, implementation, operations and safeguards are separated into dedicated documentation pages.

BLUE · INTERFACESBLACK · CORERED · SAFEGUARDS

Platform at a glance

Thirty-two documentation pages, a browser-ready SDK, a shared Matrix Encoding runtime layer and a clean contract-first model with a live AI Studio model layer.

SDK2.5.0Standalone JavaScript runtime

DOCS30Dedicated engineering pages

MODELContract-firstState · commands · events · HTTP

What developers get

Copy-ready SDK source, lifecycle rules, command execution, event subscriptions, JSON-safe state, optional HTTP transport, data contracts, security guidance and integration patterns.

Browser-native JavaScript.
No framework dependency.
Structured success and error envelopes.
Downloadable standalone SDK file.

Reality boundary

This documentation defines the project-owned XR SDK and contracts. It does not imply an already-hosted production API, package registry publication, external certification or third-party endorsement.

A real production deployment still needs your backend, authentication, infrastructure and operational policies.

Stable surface

The public concepts developers should build against.

Surface	Purpose	Entry
Runtime	Lifecycle, configuration and snapshots.	`new SearchXRXR()`
Commands	Named operations with structured results.	`xr.execute()`
Events	Ready, command, error and custom topics.	`xr.on()`
HTTP	Optional network transport.	`xr.request()`
Studio	OpenRouter + Pollinations-backed research, text synthesis and image generation surface.	`Studio & Model Matrix`

Getting Started

Go from a blank project to a working runtime with the same contract used throughout this documentation.

Install by file

Download the SDK from this documentation page, save it as searchxr-xr.js, then import it as an ES module.

import SearchXRXR from './searchxr-xr.js';
const xr = new SearchXRXR({
  name: 'Acme XR Workspace',
  version: '1.0.0',
  baseURL: 'https://api.example.com/'
});
await xr.init();

First command

Commands are local application capabilities. Keep handlers deterministic and easy to test.

xr.register('project.get', async ({ id }) => ({
  id,
  status: 'active'
}));
const result = await xr.execute('project.get', { id: 'proj_123' });
console.log(result);

Download the same SDK source

The button creates a browser download from the exact source displayed on the SDK page.

Core Concepts

Understand the runtime before connecting it to application code or a backend.

Runtime

Owns lifecycle, state, configuration and the command registry. init() is idempotent.

Command

A named async or sync function invoked through execute() and wrapped in one result format.

Event

A notification emitted by the runtime. Subscribers receive a payload and a cleanup function.

State model

`name`	Project name.
`version`	Project semantic version.
`status`	`created`, `ready` or `destroyed`.
`sdk`	SDK runtime version.
`capabilities`	Runtime capabilities.
`updatedAt`	ISO-8601 timestamp.

Result contract

{
  "ok": true,
  "name": "xr.health",
  "data": { "status": "ok" },
  "meta": { "durationMs": 2, "at": "2026-08-30T10:00:00.000Z" }
}

Branch on ok. Do not parse human-readable exception strings as application protocol.

SDK

Full standalone JavaScript runtime. The same source can be copied into a project or downloaded directly.

Lifecycle

constructor → init → ready → destroy

Core API

configure · register · unregister · execute · getState · manifest

Transport

request() uses browser fetch() with timeout and normalized errors.

API Reference

Method-by-method stable runtime reference.

CORE

new SearchXRXR(config?)

Creates an independent runtime. Config: name, version, baseURL, timeout.

ASYNC

init() → Promise<XRState>

Moves runtime to ready. Repeated calls return the current snapshot.

SYNC

configure(patch) → XRState

Merges configuration.

SYNC

register(name, handler) → SDK

Registers a local command.

VOID

unregister(name)

Removes a command.

ASYNC

execute(name, args?) → Promise<XRResult>

Runs a command or returns a structured failure.

SYNC

getState() → XRState

Returns JSON-safe state.

SYNC

manifest() → XRManifest

Returns project identity and capabilities.

SYNC

on(name, handler) → cleanup

Subscribes to an event and returns an unsubscribe function.

ASYNC

request(path, options?) → Promise<XRResult>

Optional HTTP client using fetch and AbortController timeout.

HTTP Client

Connect XR to a real backend without hard-coding a vendor, framework or database.

Set baseURL to your service. XR intentionally keeps auth and application policy outside the generic transport layer.

GET

const res = await xr.request('/v1/projects/proj_123');
if (!res.ok) {
  console.error(res.error.code, res.error.message);
  return;
}
console.log(res.status, res.data);

POST JSON

const res = await xr.request('/v1/projects', {
  method: 'POST',
  body: JSON.stringify({ name: 'New Project' })
});

Transport behavior

Timeout	AbortController based.
JSON	Attempts JSON parsing, preserves text if parsing fails.
Status	Non-2xx responses normalize to `HTTP_*`.
Network	Fetch failures normalize to `NETWORK`.

Events & Plugins

Build observability and extensions without modifying the core class.

const stop = xr.on('command', event => {
  console.log(event.name, event.meta.durationMs);
});

const stopError = xr.on('error', event => {
  console.warn(event.error.code);
});

Plugin pattern

function telemetryPlugin(xr) {
  xr.register('telemetry.flush', async () => ({
    sent: true,
    at: new Date().toISOString()
  }));
  return () => xr.unregister('telemetry.flush');
}

Reserved topics

readydestroycommanderrorcustom:your-topic

Architecture

A production reference model separating interface, runtime, services and safeguards.

01 · Interface

Docs, UI and host application integrations. User intent starts here.

02 · Runtime

XR SDK owns commands, events, state, lifecycle and optional transport.

03 · Services

Your API, auth, data store, jobs, observability and policies live beyond the generic SDK.

Reference request path

Developer action
      ↓
XR command / request
      ↓
Local validation + runtime state
      ↓
Optional HTTP transport
      ↓
Your service boundary
      ↓
Database / workers / external systems
      ↓
Structured result
      ↓
UI + telemetry

Isolation guarantee

XR documentation navigation and its local documentation runtime do not consume or depend on the host application's Search, Images, Music, Gemini or Studio state.

Insights & Metrics

Interactive reference telemetry for the XR runtime model. Values here are documentation examples, not claims about production traffic.

Commands

12Reference command families in the example contract.

Events

6Reserved lifecycle and extension event topics.

SDK

2.5.0-XRDocumentation runtime version shown by this module.

Capability mix

Reference composition • not observed usage

Reference weight

Runtime flow

Standalone execution lifecycle

01 · InitCreate runtime and validate configuration.

02 · RegisterAttach deterministic commands and handlers.

03 · ExecuteResolve command and return structured output.

04 · ObserveEmit events and inspect state snapshots.

05 · DestroyRelease handlers and close the runtime.

Reference delivery trend

Example release readiness score

The chart is generated locally from deterministic documentation data so the page never pretends these are live company metrics.

Reference matrix

Documentation surface coverage

Surface	Contract	SDK	Docs
Commands	Yes	Yes	Yes
Events	Yes	Yes	Yes
HTTP	Yes	Yes	Yes
Errors	Yes	Yes	Yes
Versioning	Yes	Yes	Yes

Important: Metrics, bars and trend values are illustrative reference data embedded in the documentation UI. The XR module does not claim live production telemetry or external company statistics.

Data Contracts

Portable JSON shapes for projects, tools and integration tests.

Manifest

{
  "id": "searchxr.xr",
  "name": "SearchXR XR Project",
  "version": "1.0.0",
  "sdk": "2.5.0-XR",
  "entry": "SearchXRXR",
  "capabilities": ["runtime","commands","events","http","state"]
}

Failure envelope

{
  "ok": false,
  "error": {
    "code": "NOT_FOUND",
    "message": "Unknown command",
    "name": "project.get"
  },
  "meta": { "at": "2026-08-30T10:00:00.000Z" }
}

Contract principles

JSON-safe	Serializable in tests, logs and network payloads.
Explicit	Stable field meanings; no hidden positional semantics.
Versioned	Breaking contract changes require a major version.
Traceable	Responses include useful metadata and timestamps.

Security

Security belongs around the runtime as well as inside application boundaries.

Secrets

Never place private server credentials in browser-delivered source.

Authorization

Backend authorization is the source of truth. Hiding a UI button is not access control.

Validation

Validate external inputs at every trust boundary.

Production checklist

HTTPS for protected services.
Server-side auth and least privilege.
Rate-limit expensive operations.
Redact secrets and personal data from logs.
Restrict CORS according to the deployment.
Separate environment-specific endpoints.
Monitor errors, latency and timeouts.

The generic SDK transport does not create your authentication system. Integrators must supply appropriate credentials and authorization mechanisms.

Errors & Reliability

Predictable codes make UI and service handling easier to test.

Code	Cause	Response
`NOT_READY`	execute before init.	Initialize first.
`NOT_FOUND`	Unknown command.	Check registration/name.
`INTERNAL`	Handler threw.	Log safely and show controlled failure.
`HTTP_4xx`	API rejected request.	Fix request/auth/policy.
`HTTP_5xx`	Service-side error.	Observe and retry only when safe.
`NETWORK`	Fetch did not complete.	Check connectivity/service.
`TIMEOUT`	AbortController limit hit.	Optimize or carefully adjust timeout.

Retry policy

XR does not auto-retry because a blind retry can duplicate mutations. Add retries only where the operation is idempotent or protected by an idempotency strategy.

Observability

Subscribe to command and error, then send redacted telemetry to your own monitoring stack.

Examples

Practical copy-ready patterns for browser apps and service integrations.

Complete mini application

import SearchXRXR from './searchxr-xr.js';

const xr = new SearchXRXR({
  name: 'Example Workspace',
  version: '1.0.0',
  baseURL: 'https://api.example.com/'
});

xr.register('greet', async ({ name = 'Developer' }) => ({
  message: `Hello, ${name}`
}));

xr.on('error', e => console.error('[XR]', e.error.code));
await xr.init();

const local = await xr.execute('greet', { name: 'Sahitya' });
console.log(local.data.message);

const remote = await xr.request('/v1/projects');
if (remote.ok) console.log(remote.data);

Command-driven UI

Button → loading state → execute() → branch on ok → render sanitized data.

Testing

Changelog

Documentation and SDK evolution in one release track.

2.5.0-XRStandalone lifecycle, command registry, events, manifest and fetch transport.STABLE

2026.1Expanded engineering docs, 21-page reference, security, data contracts and module updates.DOCS

2.4.xEarlier project integration experiments.LEGACY

Compatibility policy

Minor and patch releases should preserve existing method names and result envelopes. Breaking contract changes should increment the major SDK version and ship migration guidance.

Leadership & Founder

Advanced project attribution, ecosystem ownership and leadership context for SearchXR and X-Star Community.

Sahitya

Founder & Lead Developer · SearchXR
Founder & CEO · X-Star Community

SearchXR is an open-source ecosystem within X-Star Community. It is developed and maintained as part of the wider X-Star Community open-source ecosystem, with Sahitya serving as the founder and lead developer of SearchXR and the founder and CEO of X-Star Community.

The SearchXR identity therefore represents a project ecosystem under X-Star Community rather than a separate organization unrelated to it.

◎ Instagram · @sahitya.official001

SearchXR

Open-source ecosystem
SearchXR is an open-source ecosystem within X-Star Community, covering the SearchXR platform, XR modules, SDK, documentation and related developer surfaces.

X-Star Community

Parent open-source community
X-Star Community is the broader open-source ecosystem in which SearchXR is developed and positioned.

Leadership

Sahitya
Founder & Lead Developer of SearchXR and Founder & CEO of X-Star Community.

Ecosystem model

SearchXR should be described as a project ecosystem inside X-Star Community. Its modules, documentation and developer runtime are part of that broader open-source community structure.

Attribution rule

Public-facing SearchXR metadata and documentation should identify X-Star Community as the parent ecosystem and Sahitya as the founder-led project and community leadership identity.

VeoXR Module

VeoXR is the dedicated Rati Pandey video surface inside SearchXR XR. Its primary purpose is to connect SearchXR with the official Rati Pandey channel/feed experience and present that content as a focused video environment.

VEOXR · RATI PANDEY

PRIMARY SOURCERati PandeyOfficial channel / creator feed represented by this module

ROLEDedicated SurfaceVideo-first presentation inside SearchXR

BEHAVIOROriginalCurrent VeoXR UI and embedded behavior are preserved

What VeoXR is for

This page removes ambiguity: VeoXR is not intended to be a general-purpose video search engine. It is a dedicated presentation layer centered on Rati Pandey's official content experience.

Primary connection

VeoXR is mainly connected to Rati Pandey's official channel/feed. The module exists to surface that creator's video content inside the SearchXR environment. The current embedded implementation uses the rati-pandey creator feed surface already bundled with VeoXR, with the module focused on Rati Pandey Shorts/video content.

Creator focus: Rati Pandey.
Primary content scope: Rati Pandey official creator/channel Shorts/video feed.
Presentation: dedicated, video-first VeoXR surface.
Purpose: keep the viewer focused on the creator ecosystem rather than generic discovery.

Clarity boundary

VeoXR should not be described as a generic YouTube search tab. Search, discovery and unrelated platform content remain outside the VeoXR product definition unless a future release explicitly changes that contract.

Documentation rule: When describing VeoXR, identify the primary source as the official Rati Pandey channel/feed and avoid implying a broader video-search scope than the implementation provides.

Current implementation

The host integration remains exactly as previously implemented. This update is documentation-only: no VeoXR search, feed logic, viewer behavior or embedded source is changed.

Layer	Current behavior	Contract
SearchXR navigation	User opens the dedicated Veo route from the host application.	`data-view="veo"`
Host view	The host exposes one isolated Veo container.	`#veoView`
Embedded surface	The existing VeoXR application is rendered inside its iframe.	`#veoXRFrame`
Mount model	The VeoXR source is mounted through the existing isolated `srcdoc` lifecycle.	Existing mount guard
Content identity	Primary creator/content identity is Rati Pandey's official channel/feed.	VeoXR product definition

Source and isolation contract

VeoXR remains a self-contained embedded application so its document-level CSS, scripts and runtime do not leak into the SearchXR host.

Source integrity

The current VeoXR embedded document is preserved exactly as supplied. Documentation changes do not modify its UI or content runtime.

Host isolation

The host keeps VeoXR inside #veoXRFrame, preventing VeoXR's internal styles and document listeners from becoming global SearchXR state.

Navigation integrity

The existing Veo route and isolated mount remain the stable host contract.

VeoXR documentation promise

Every future VeoXR update should make the Rati Pandey connection clearer rather than introducing ambiguity about what the module is.

Describe VeoXR as a Rati Pandey–focused creator surface.
Keep unrelated Search, Music, Image and Studio capabilities separate from the VeoXR definition.
Never claim a live or current content state unless the underlying source actually confirms it.
Preserve the existing UI/runtime behavior when making documentation-only changes.

Map Module

Advanced engineering documentation for the embedded SearchXR Map workspace. This page documents the implementation surface present in the current build, its data flow, interaction model, network dependencies, and safe extension points.

MAP · OSM + PHOTON

ENGINELeafletMap runtime loaded by the embedded workspace

BASE MAPOSMOpenStreetMap tile layer is the default view

SEARCHPhotonPlace search and reverse geocoding path

Capability matrix

The current map build exposes a focused, browser-first feature surface rather than a broad mapping SDK.

Capability	Current behavior	Primary implementation surface	Boundary
Map rendering	Interactive pan/zoom map centered on a stored latitude/longitude state.	`L.map()` + Leaflet tile layer	Requires map tiles to load from the network.
Place search	Typed query is sent to Photon with the current map center as context; up to eight features are mapped into local result objects.	`photon.komoot.io/api/`	Third-party service availability and rate limits are external.
Reverse geocoding	Map clicks trigger a Photon reverse lookup and create a structured place result or coordinate fallback.	`photon.komoot.io/reverse`	A failed lookup falls back to raw coordinates.
Current location	Browser geolocation flies the map to the reported device coordinates and drops a “You are here” marker.	`navigator.geolocation`	Permission and browser support are user-controlled.
Directions	Selected coordinates can open a Google Maps directions URL in a new tab.	`https://www.google.com/maps/dir/`	Routing itself is delegated to the external service.
Layer switch	Toggle between the OSM map tiles and an ArcGIS World Imagery tile layer.	Leaflet tile-layer replacement	Imagery is a separate external tile source.

Runtime pipeline

SearchXR hosts the module; the map workspace owns its internal rendering state and only exposes the iframe boundary to the host.

01 · Host viewdata-view="map" selects #mapView.

02 · MountSearchXR assigns the embedded map document to the iframe through srcdoc.

03 · LeafletLeaflet creates the map, tile layer and marker layer inside the isolated document.

04 · Geo lookupSearch and map-click actions call Photon and normalize results into local objects.

05 · User actionSelection updates the map, popup state, coordinates, or an external directions hand-off.

Normalized place object

The map implementation converts Photon features into a predictable object used for list rendering and markers. The normalized fields include an id, name, address, type, latitude, longitude and the raw provider feature.

{
  "id": "provider-id",
  "name": "Place name",
  "address": "Readable address",
  "type": "category:value",
  "lat": 28.6139,
  "lng": 77.2090,
  "raw": { "provider": "feature" }
}

Interaction states

Idle: map visible, optional nearby suggestions.
Searching: loading state while Photon is queried.
Results: list results plus map markers.
Selected: map flies to the place and a popup is opened.
Located: browser location is shown with a device marker.
Fallback: raw coordinates are preserved when reverse geocoding fails.

Search and reverse-geocode contract

These are documentation-level contracts extracted from the current embedded implementation.

Operation	Input	Success	Failure behavior
Search	query + current center	Photon features → normalized places → markers	Empty results or controlled “search failed” notice
Reverse	map click latitude/longitude	First Photon feature becomes the selected place	Coordinate-only fallback place
Locate	browser permission	Map flies to device coordinates and shows marker	Permission denied / unsupported notice
Directions	selected latitude/longitude	External Google Maps directions tab	Depends on browser popup/navigation policy

Network and dependency profile

The module is not a fully offline map. Its renderer, tiles, geocoder and imagery paths are network-backed.

Leaflet loader

The embedded source first attempts the Leaflet module, then falls back to the public Leaflet script when the runtime is online.

Tile providers

Default tiles use OpenStreetMap; the alternate imagery layer uses an ArcGIS World Imagery tile endpoint.

Geocoding

Photon is used for forward search and reverse geocoding. Provider response shape is converted before rendering.

Production boundary: SearchXR's host integration does not create ownership, uptime, licensing, quota or SLA guarantees for external tile, geocoding, imagery or routing providers. Verify provider terms before production use.

Extension guide

Safe places to extend the current module without changing the SearchXR host contract.

Provider adapter

Keep provider-specific fetch/parsing inside an adapter that outputs the same normalized place object.

UI features

Add saved places, categories, marker clustering or route overlays inside the embedded map document so host CSS remains isolated.

Host contract

Keep data-view="map", #mapView and the single iframe mount lifecycle stable.

Map checklist

Operational checks before calling the module production-ready.

Tiles	Confirm required tile sources remain reachable and comply with their attribution requirements.
Geolocation	Use a secure context and test denied, unavailable and timeout paths.
Provider errors	Keep user-facing failures controlled; never expose raw provider payloads as trusted UI text.
Popup safety	Sanitize provider-controlled strings before injecting them into HTML popups.
Performance	Debounce text search and avoid recreating the map instance on every state update.
Host isolation	Preserve the iframe boundary unless the module is deliberately re-architected.

Geo Module

Geo is the SearchXR social-video feed surface powered by the supplied Juicer embed. The module keeps the external feed presentation intact and is used to surface video content from the configured official-channel set.

GEO · OFFICIAL CHANNEL FEED

PROVIDERJuicerExternal social-feed embed

FEEDUCfNPmyLCMkTOFoHzjB_YeJgConfigured Juicer feed identifier

DELIVERYLive FeedVideo updates are surfaced through the embedded feed

Official channel coverage

The Geo feed is documented as the official-channel video surface for the following channel set. Their video content is intended to appear through the live feed connection.

SET India

Official channel video feed.

Sun Neo

Official channel video feed.

Sony Music

Official channel video feed.

Sony WAH

Official channel video feed.

Goldmines

Official channel video feed.

Shimarooh TV

Official channel video feed.

Embed contract

The Geo host view renders the supplied Juicer iframe exactly as provided. No custom Geo gallery, reel database, map, geocoder, or replacement UI is included here.

<iframe src="https://www.juicer.io/api/feeds/ucfnpmylcmktofohzjb_yejg/iframe" frameborder="0" width="1000" height="1000" style="display:block;margin:0 auto;width:1000px;height:1000px;" title="UCfNPmyLCMkTOFoHzjB_YeJg - Juicer social media feed"></iframe>

Boundary

SearchXR provides the host navigation entry and iframe container. Feed content, channel availability, ordering, presentation, and provider-side delivery remain controlled by the connected Juicer feed.

The old bundled Geo application and its custom runtime are removed.
The Geo module does not reinterpret the feed as a map or geocoding workspace.
No custom UI/UX layer is added around the supplied embed.
Future Geo changes should update the embed contract only when the supplied feed source changes.

Explainer Module

The Explainer module is the dedicated SearchXR media surface for the supplied logic-decode explainer video. It keeps the presentation focused on one video asset and exposes it through the same SearchXR module navigation.

EXPLAINER · LOGIC DECODE

STATUSINTEGRATEDAvailable as a SearchXR module and XR documentation page

ASSETsearchXR_लॉजिक_डिकोड.mp4Supplied explainer media embedded in this build

MEDIA1280×720 · H.264/AAC24 fps video with an approximately 7:15 runtime

Purpose

The module provides a direct place inside SearchXR to watch the supplied Explainer asset. The current implementation is intentionally media-first: the module presents the video rather than adding a separate search, feed, or content system around it.

Asset identity

The supplied file is named searchXR_लॉजिक_डिकोड.mp4. In this build, the MP4 is embedded into the HTML payload and converted into a browser object URL when the Explainer view is opened.

Module behavior

Only the functionality required for the supplied explainer asset is documented here.

Capability	Explainer behavior	Role
Playback	Native HTML5 video player with browser controls.	Watch the supplied explainer directly.
Responsive media	Video is displayed inside the SearchXR Explainer surface and supports inline playback.	Provide a consistent module experience across screen sizes.
Lazy module loading	The embedded MP4 is decoded when the Explainer view is selected.	Avoid initializing the media object before the module is needed.
Standalone asset	No external video feed or search API is required by the Explainer module itself.	Keep the explainer surface self-contained.

Integration contract

The Explainer module is mounted as its own SearchXR view and remains separate from the existing SearchXR runtime documentation state.

Host view

data-view="explainer" targets #explainerView.

Player surface

#explainerVideo is the HTML5 <video> element used for playback.

Boundary

The Explainer module should remain a focused video surface. Do not silently redefine it as a generic media search or feed module without documenting that change.

Source and preservation rule

The Explainer documentation describes the exact supplied asset and its current host integration, without changing the video content itself.

Preserve the supplied searchXR_लॉजिक_डिकोड.mp4 asset when making documentation-only updates.
Keep native playback controls and inline playback behavior available.
Keep the Explainer view independent from other modules, Geo, Veo, Gemini and other SearchXR modules.
Document any future replacement of the asset as a new Explainer release rather than silently changing the source.

Updates

No current updates are documented on this page.

UPDATES

Gemini Evidence Intelligence

A dedicated SearchXR intelligence capability that lets Gemini inspect module evidence centrally, identify the most relevant reel or record, and produce grounded answers without opening or navigating the source module.

GEMINI · EVIDENCE INTELLIGENCE

ACCESS MODELREAD-ONLYCentral context with navigation disabled

REEL MODEVISUAL + DATACaption, id, media, thumbnail and sampled frames when available

VERDICT4-WAYSAME · RELATED · NOT SAME · NOT ENOUGH EVIDENCE

What this special Gemini power does

Gemini can answer natural requests such as “Geo me ye reel dekhna aur bata” or “VeoXR me ye short dekh ke summary de” from one central SearchXR context. It does not open Geo. It first resolves the likely reel from the bundled record set, then reads its exact metadata and attempts live visual evidence from the reel media when the browser can fetch it.

Reel identification

The intelligence layer can match a user request against the reel catalog by caption, post id, ordinal position and distinctive terms. The selected record is passed as structured evidence rather than as an instruction to navigate the UI.

Exact caption and post id are preferred evidence.
Distinctive caption terms are used for related matching.
“First/second/third reel” references can use bundled ordering when unambiguous.
Ambiguous requests return NOT ENOUGH EVIDENCE instead of guessing.

Visual evidence mode

For supported reel media, Gemini can attempt browser-side sampled-frame inspection. The system captures representative frames from the beginning, middle and later portion of the available video and sends those visual samples with the record metadata.

Frame capture happens only when media is reachable from the browser.
The live status reports the actual capture operation.
Visual claims are limited to what the sampled frames support.
Unavailable media falls back to caption, id and thumbnail evidence.

Evidence decision model

Gemini separates exact matches from topical relationships and keeps evidence boundaries explicit.

Verdict	Meaning	Typical evidence
SAME	The requested item and discovered record/claim are the same.	Exact caption, same post id, or matching visual/content identity.
RELATED	The evidence points to the same subject or theme, but not the same item/claim.	Similar caption/topic with different id or materially different content.
NOT SAME	The available evidence distinguishes the items or claims.	Different caption, id, creator scope or incompatible visual evidence.
NOT ENOUGH EVIDENCE	The current central context cannot prove the requested claim.	Ambiguous reel reference, unreachable media or insufficient visual/data evidence.

Live activity contract

The Gemini UI is not a scripted progress animation. Every visible activity label corresponds to an actual operation being attempted or completed.

Central read

The UI can show Reading Geo…, Reading VeoXR… or another module-specific state while the central snapshot is assembled.

Visual inspection

When a reel frame is actually being captured, Gemini shows the live capture state and then moves to evidence analysis.

Web grounding

When current verification is requested, the app reports the real Google grounding/search operation instead of inventing a fixed sequence.

Gemini correctness & bug-guard rules

These rules prevent same-name products, generic model knowledge and external search results from silently overriding SearchXR module identity.

Namespace lock

Veo inside a SearchXR question resolves to SearchXR VeoXR and its Rati Pandey-focused video/Shorts surface unless the user explicitly requests Google's generative Veo technology. Gemini must never say that SearchXR VeoXR is a Google Veo model.

Source priority

For “what does this SearchXR module do?”, bundled SearchXR docs/source and live module state outrank generic model memory. Web search is an optional verification layer, not a replacement for the module's own definition.

Studio parity

Studio shares the central SearchXR context contract for module-aware requests. Text work uses text-capable OpenRouter models; image creation can use either an OpenRouter image model or a Pollinations image model through the dedicated OpenRouter Images API or the official Pollinations SDK. The live Studio & Model Matrix is the capability index for current model options.

Trust boundary

Gemini must never present unavailable evidence as if it were observed.

Important: Frame sampling is not the same as watching every frame of a reel or short. When media cannot be fetched or sampled evidence is insufficient, Gemini must say so. This capability is designed to be stronger than caption-only matching while remaining grounded in the evidence actually available to the browser.

Live visual reel understanding

When a user asks Gemini to look at a Geo reel, the intelligence layer attempts real browser-side visual inspection of the selected media using the already mounted reel, the exact media URL and finally its thumbnail. No module navigation is required.

LIVE LOOKING

Visual summary power

When frames are captured, Gemini can summarize visible people, setting, actions, objects, on-screen text and meaningful changes across sampled moments for both Geo Reels and VeoXR Shorts.

Representative frames are sampled across the available reel duration.
Live activity text reports the real inspection operation.
Claims are grounded only in captured frames and structured reel metadata.
Audio or unseen moments are never invented from images.

Evidence boundary

Cross-origin social/CDN media can block browser frame extraction. In that case Gemini reports metadata-only evidence instead of falsely claiming it watched the reel.

LIVE VISUAL INSPECTION = frames captured and sent.
METADATA-ONLY = reel metadata/thumbnail only.
NOT ENOUGH EVIDENCE = the request cannot be established reliably.

xTV

SearchXR ka official video-module surface. xTV ko real video discovery, YouTube-compatible playback, responsive presentation aur resilient upstream data routing ke liye design kiya gaya hai. Is page par xTV ki architecture, powers, playback model aur operational boundaries documented hain.

xTV · VIDEO PLATFORM

IDENTITYxTVSearchXR video module

PLAYERYouTubeOfficial YouTube embed/player interface

DISCOVERYMulti-sourceSearch + trending endpoint fallback

Official YouTube playback logic

xTV ka playback layer YouTube ke official embedded player interface ko use karta hai. Video ID ko normalize karke https://www.youtube.com/embed/{videoId} player surface me load kiya jata hai, jisse playback YouTube ke supported embed environment ke through hota hai.

Player contract

YouTube video ID based playback.
Embedded player with API-enabled query parameters where supplied by the module.
Fullscreen playback support.
Standard media permissions for playback, clipboard and picture-in-picture.
Responsive player sizing for desktop and mobile surfaces.

Important boundary

xTV YouTube ka replacement ya YouTube-branded first-party product nahi hai. Playback interface official YouTube embed surface par depend karta hai, jabki xTV ka SearchXR-owned layer discovery, presentation, normalization aur module orchestration handle karta hai.

Complex powers

xTV simple static video card nahi hai. Module ke bundled implementation me multiple upstream endpoints, resilient fetch fallback aur normalized video records ka flow hai.

Real video search

User query ko video-focused search endpoints ke against request kiya jata hai. Search results ko normalize karke common xTV record me convert kiya jata hai.

query → endpoint rotation → JSON → normalize → video cards

Trending discovery

Regional trending feed ke liye configured upstream endpoints ka fallback chain rakha gaya hai, jisse ek source unavailable hone par agla source try ho sakta hai.

region=IN → source A → source B → source C

Resilient data flow

HTTP response ko validate karke JSON parse hota hai. Failure par next configured endpoint try hota hai aur complete failure ko controlled module error state me return kiya jata hai.

Video data normalization

xTV alag upstream response shapes ko ek consistent rendering contract me map karta hai.

Field	Purpose	Behavior
`videoId`	Canonical playback identifier.	URL, ID ya supported path patterns se extract kiya jata hai.
`title`	Video display title.	Missing hone par safe fallback title use hota hai.
`thumbnail`	Preview media.	Common thumbnail fields se resolve hota hai; protocol-relative URLs ko HTTPS me normalize kiya jata hai.
`uploaderName`	Channel/uploader label.	Supported uploader fields se resolve hota hai.

UI & playback powers

xTV ka visual layer real video discovery ko app-style browsing experience ke saath combine karta hai.

Responsive video grid

Viewport width ke according single-column, two-column aur three-column layouts use hote hain, isliye same module desktop aur mobile contexts me adapt karta hai.

Focused player view

Card select karne par player context top par focus hota hai aur selected video ka title/uploader metadata playback surface ke saath show hota hai.

Real thumbnails

Resolved thumbnail URL ko lazy image rendering ke through card preview me use kiya jata hai, aur missing thumbnail ke liye safe fallback state available hai.

Architecture

xTV ek isolated SearchXR module ke roop me host hota hai, isliye core SearchXR documentation/runtime ke saath direct UI coupling ko minimum rakha gaya hai.

Module path

SearchXR Host
   ↓
xTV Module Shell
   ↓
Discovery / Trending Fetchers
   ↓
Video Normalizer
   ↓
Responsive Cards
   ↓
YouTube Embedded Player

Operational characteristics

Lazy module loading inside the host.
Independent iframe/srcdoc isolation for the bundled app surface.
Endpoint fallback for discovery requests.
Controlled empty, loading and failure states.
Fullscreen player action through the host module.

Integration note

xTV ko SearchXR ke module architecture ke saath add kiya gaya hai bina existing XR documentation pages ko replace kiye. Is doc page ka naam aur module identity sirf xTV hai.

xTV contract: SearchXR owns the module shell and presentation layer; YouTube provides the embedded playback surface used for compatible video IDs; configured discovery endpoints provide searchable/trending video metadata. Availability and behavior of third-party upstream services can change independently.

Vidtube Module

Vidtube is SearchXR's dedicated video aggregator for resolving YouTube channel IDs, playlist IDs, handles and video IDs into a continuously rendered video feed. The supplied module focuses on fast, resilient aggregation and uses the official YouTube embed player for compatible playback.

VIDTUBE · VIDEO AGGREGATOR

IDENTITYVidtubeSearchXR video aggregation module

DISCOVERYYouTube IDsChannel, playlist, handle and video identifiers

PLAYEROfficial EmbedYouTube's supported embedded player surface

What Vidtube does

Vidtube is designed as SearchXR's own aggregation layer: a user can supply a YouTube channel ID or another supported YouTube locator, and the module resolves available public video metadata into a feed UI. The bundled source uses multiple public upstream paths with failure fallback so one unavailable provider does not have to stop the entire module.

Identifier-first discovery

Accepts direct YouTube video IDs.
Accepts channel IDs and supported channel URLs/handles.
Accepts playlist IDs and supported playlist URLs.
Normalizes supported input forms before requesting upstream video data.
Deduplicates and combines resolved video records for feed rendering.

Resilient aggregation

The supplied implementation contains multiple public Piped-style and Invidious-style endpoints plus YouTube RSS proxy fallbacks. Requests use timeouts and failover behavior, so the UI can continue when an individual upstream endpoint is unavailable.

Operational boundary: upstream providers, proxies, quotas, availability and network conditions can change. “Unlimited” describes the feed's lack of a hard UI result-count cap; it is not a promise of unlimited third-party service quota or uptime.

Official YouTube playback

Vidtube does not need the YouTube Data API or the YouTube IFrame Player API JavaScript library to render the supplied player surface. Once a compatible YouTube video ID is resolved, the module opens the standard embedded player URL used by YouTube for iframe playback.

Playback contract

Playback target: https://www.youtube.com/embed/{videoId}.
Autoplay is requested by the supplied module when the user opens the focused player.
Fullscreen, picture-in-picture and standard media permissions are exposed where the browser/player permits them.
The embedded player remains the YouTube player; SearchXR supplies the surrounding discovery, normalization and presentation layer.

Important boundary

Vidtube does not bypass YouTube, remove YouTube restrictions, or turn a YouTube video into a raw unrestricted media file. Playback is still subject to the source video's embed availability, browser policies, Content Security Policy and the provider's terms.

Feed rendering & UI

The original supplied Vidtube UI is preserved inside an isolated module frame so its React/Tailwind styling does not overwrite SearchXR host styles.

Original module UI

The supplied black, app-first interface remains the inner module UI, including the identifier input, add action, source cards, scrolling feed and focused player.

Embedded isolation

The module runs in its own iframe document. This keeps the bundled React runtime, Tailwind utility classes and local component styles independent from SearchXR's main CSS.

Responsive surface

The source build includes responsive breakpoints for one-, two- and three-column layouts and an aspect-ratio video player that adapts to phone and desktop widths.

Module architecture

Vidtube separates the host shell from the supplied aggregation runtime.

Runtime path

SearchXR Host
   ↓
Vidtube Module Shell
   ↓
Input Normalizer
   ↓
Channel / Playlist / Video Resolver
   ↓
Upstream Fetch Fallbacks
   ↓
Normalized Video Records
   ↓
Original Vidtube Feed UI
   ↓
Official YouTube Embedded Player

Integration contract

Host view: data-view="vidtube" with #vidtubeView.
Embedded frame: #searchXRVidtubeFrame.
Source bundle: SEARCHXR_VIDTUBE_B64.
Gemini module context can read the host/module state when browser same-origin access is available.

Use from another website

The supplied Vidtube UI can generate iframe embed snippets for its own feed/player views. A receiving website can embed a Vidtube-hosted document when that host permits framing; a site cannot force another site's CSP, X-Frame-Options or provider policies to allow embedding.

Practical rule: use Vidtube as an aggregator and presentation layer. Use the official YouTube embed surface for playback, and verify the target environment's framing, autoplay, CSP and provider-policy requirements before production deployment.

Source preservation

This module is based on the supplied index.html source. Its original visual surface and bundled runtime are embedded as the Vidtube module rather than rewritten into a different UI.

Old Version

Legacy SearchXR XR deployment retained as a direct reference point for compatibility checks, migration review and historical comparison.

STATUSLEGACYHistorical reference surface

HOSTNetlifyPrevious public deployment

ACCESSPublic URLOpen in a new tab

Previous deployment

The earlier public XR deployment is available at the URL below. This link is kept as a historical reference and is not treated as the current SearchXR runtime.

Open nova-xr.netlify.app ↗

Migration boundary

Use the legacy deployment for comparison only. Current module behavior, documentation pages and integration contracts are maintained in this SearchXR build.

Legacy URL: https://nova-xr.netlify.app/

Reference policy

Recommended use of the historical deployment during development.

Compatibility

Compare UI, routes and runtime behavior before introducing breaking changes.

Migration

Record differences between legacy behavior and the current contract-first XR surface.

External dependency

The linked deployment can change independently of this local SearchXR document.

Studio & Model Matrix

All Studio model options in one simple, readable model list. Text, image, tools and reasoning capabilities come from the provider catalogs used by SearchXR.

OPENROUTER + POLLINATIONS

MODELS—Selectable Studio models

TEXT—Text-capable models

IMAGE—Image-capable models

All Studio models

Same simple presentation style as the Studio selectors: one model per line, same text scale, no oversized cards.

Loading live model catalog…

Image models

All image models exposed by the OpenRouter and Pollinations image catalogs, kept in the same simple model-list format.

Loading image models…

Image generation runtime

SearchXR uses the direct Pollinations image HTTP API as the primary browser path, with the official SDK available as a secondary path. This avoids making image generation depend on the SDK module loading successfully.

POLLINATIONS

Surface	Implementation	Purpose
Model discovery	`GET /image/models`	Loads the current image model list.
Primary image generation	`GET /image/{prompt}`	Direct browser generation without an SDK dependency.
SDK fallback	`@pollinations/sdk@5.0.0`	Secondary generation path when the browser SDK is available.
OpenAI-compatible	`POST /v1/images/generations`	Optional server/API integration path.

Capability definitions

These are provider-advertised capabilities, not quality rankings.

TEXTText generation through the existing OpenRouter Studio flow.

IMAGEImage generation through OpenRouter image models or Pollinations image models.

TOOLSTool calling only when the selected OpenRouter model advertises the required parameters.

REASONINGReasoning-related support is shown when the provider metadata exposes it.

Source: OpenRouter and Pollinations live model metadata are used when available; fallback entries remain only for catalog outages. Model availability, pricing and supported parameters can change independently of the SearchXR UI.

X-Drop Module

X-Drop is a live browser-based file sharing module that uses WebRTC data channels through PeerJS to connect peers and transfer files directly from one browser session to another.

X-DROP · WEBRTC

TRANSPORTWebRTCLive peer data channel

TRANSFERBinary chunksFiles are streamed in real time

MODULEX-DropSearchXR peer-to-peer file sharing

What X-Drop does

The module provides a real browser-to-browser transfer workflow instead of a static upload mockup.

Live file sharing

X-Drop creates a peer connection and transfers selected files over a WebRTC data channel. The sender exposes a share link and QR code so another browser can connect without uploading the file to a conventional storage service.

Multiple files can be selected or dropped.
File metadata is sent before binary content.
Binary data is transferred in chunks.
Real transfer progress and speed are shown in the UI.

Receiver experience

The receiver opens the X-Drop link, connects to the sender peer and reconstructs the incoming file as a browser Blob.

Images can be previewed directly.
Videos can be previewed in the browser.
Audio can be previewed in the browser.
Other file types can be downloaded after transfer.

Transfer flow

The current implementation follows a clear peer-to-peer lifecycle.

select or drop file
      ↓
create PeerJS / WebRTC peer
      ↓
create share link + QR
      ↓
receiver connects to sender
      ↓
send file metadata
      ↓
send binary chunks over the data channel
      ↓
receiver rebuilds Blob
      ↓
preview or download the received file

Implementation boundary

X-Drop is a browser module. Connection establishment, signaling availability and network traversal remain dependent on the WebRTC/PeerJS runtime and the configured STUN infrastructure.

Real runtime

The UI reports the actual connection and transfer state generated by the live PeerJS/WebRTC flow.

Direct transfer model

When a usable peer path is established, file bytes move through the WebRTC data channel between participating browser peers.

Network boundary

WebRTC connectivity can be affected by browser policy, NAT/firewall conditions, signaling availability and third-party network services.

Steganography Module

SearchXR Stego is a browser-side image steganography workspace for hiding a secret message inside an image and decoding that message later from the resulting stego image.

STEGO · LSB · CLIENT-SIDE

METHODR-CHANNEL LSBOne least-significant bit per red-channel pixel is used for the payload.

HEADER32-BIT LENGTHThe payload byte length is stored before the hidden message bits.

OUTPUTPNGThe encoded canvas is exported as a PNG image.

Encoding workflow

The supplied implementation accepts common image inputs, normalizes them through a canvas, optionally encrypts the message, embeds the resulting bytes, and exports the encoded image.

image input
    ↓
Canvas normalization
    ↓
optional AES-GCM encryption
    ↓
32-bit payload-length header
    ↓
message bits written into red-channel LSBs
    ↓
PNG export
    ↓
stego image download

Supported image input

PNG
JPEG
WebP
Drag-and-drop or file browsing is supported.
Input is drawn to a browser canvas and converted to PNG for output.

Message capacity

Capacity is calculated from the usable pixel count with a 32-bit header reserved for the message length. The interface reports the calculated capacity and blocks an encode when the payload is too large.

Optional password protection

The supplied implementation can encrypt the secret message before steganographic embedding. The password is never sent to a server by this module.

AES-GCM

Key derivation

Password material is processed with PBKDF2 using SHA-256 and 120,000 iterations.

Encryption

The derived key is used with AES-GCM 256-bit encryption and a random salt/IV generated in the browser.

Decode rule

During decoding, the hidden Base64 payload is decrypted only when a password is supplied; an incorrect password produces a controlled decryption error.

Decoding workflow

The decoder reads the 32-bit length header from the red-channel least-significant bits, reconstructs the byte payload, converts it back to text, and optionally decrypts it.

Validation

The implementation checks for an invalid length header, insufficient data, corrupted payload length and incomplete message data before returning decoded text.

Client-side boundary

The visible module identifies itself as client-side and “OFFLINE • NO NETWORK.” Image processing, encoding, decoding, encryption and copying are performed in the browser runtime.

UI capabilities

The supplied module is a complete Encode + Decode workspace rather than a documentation-only example.

Encode

Upload an image, enter a secret message, optionally set a password, encode it, preview the resulting PNG and download it.

Decode

Upload a previously encoded image, optionally enter its password, decode the hidden message and copy the result.

Responsive surface

The supplied React/Tailwind build uses one-column layouts on narrow screens and two-column encode/decode panels at larger widths.

Security boundary: This module is steganography plus optional client-side encryption. It does not make a message invisible to forensic analysis, and the presence of an encoded PNG does not prove the payload is secret unless the optional password encryption is used.

Security Core

Standalone SearchXR security controls exposed from the header gear. This page states the cryptographic mechanisms and browser APIs actually used by the module: password-derived AES-256-GCM encryption for protected exports, Ed25519 challenge signatures for connection identity, local audit/error reporting, cache controls, QTEL CORE Worker execution, RAS CORE heuristic code review and the shared Matrix Encoding runtime layer.

SECURITY · LOCAL-FIRST

Cryptography at a glance

These are the concrete cryptographic steps performed in the browser. No claim is made that the browser can hide delivered source code or prove that a connection belongs to a human.

AES-256-GCM protected export

Purpose: protect a downloaded SearchXR data package while it is stored or moved outside the page.

A random 128-bit salt is generated for the export.
A random 96-bit AES-GCM IV/nonce is generated for the encryption operation.
The user password is processed with PBKDF2 using SHA-256 and 310,000 iterations to derive 256 bits of key material.
The application snapshot is encrypted with AES-GCM.
AES-GCM also produces an authentication tag, so modified ciphertext fails verification during decryption.
The exported package stores the format version, KDF parameters, salt, IV and ciphertext; the password itself is never stored in the package.

password
  ↓ PBKDF2-SHA-256, 310000 iterations, random salt
256-bit key
  ↓ AES-GCM, random 96-bit IV
ciphertext + authentication tag
  ↓
.searchxr-secure file

Ed25519 challenge proof

Purpose: verify that the browser controls the private key belonging to the published public key/fingerprint.

SearchXR maintains an Ed25519 keypair in browser storage.
A fresh random challenge is generated for a proof operation.
The private key signs that challenge.
The public key verifies the signature.
A valid result proves possession of the private key corresponding to the public key.

challenge ←$ random bytes
signature = Sign_ed25519(privateKey, challenge)
valid = Verify_ed25519(publicKey, signature, challenge)

Boundary: this is cryptographic proof-of-possession, not proof that the user is human, trusted, or non-automated.

Cryptographic security properties

What each mechanism protects, and what it does not.

Mechanism	What it protects / proves	What it does not prove
AES-256-GCM	Confidentiality and authenticated integrity of the encrypted export when the correct password is available and the ciphertext is not altered.	It does not protect the password, secure an already-compromised browser, or hide the JavaScript delivered to the browser.
PBKDF2-SHA-256	Derives key material from the password with a per-export random salt and configured work factor.	It does not make a weak password strong by itself; password quality remains important.
Ed25519	Authenticates possession of a private signing key through challenge/response.	It does not establish a person's real-world identity or classify humans versus bots.
Random salt / IV	Separates independent exports and ensures each AES-GCM encryption uses fresh nonce material.	It is not a secret and does not replace the password.

EXPORT CIPHERAES-256-GCMRandom salt + IV with password-derived key material.

CONNECTION IDEd25519Challenge signing verifies possession of the local private key.

WORK EXECUTIONWeb WorkerQTEL moves hash/scan work off the main UI thread.

Protected data export

SearchXR can package selected local application data into a versioned encrypted file. The password never leaves the browser.

password
   ↓
PBKDF2-SHA-256 + random salt
   ↓
256-bit AES-GCM key
   ↓
JSON application snapshot
   ↓
AES-256-GCM ciphertext + IV + salt
   ↓
.searchxr-secure download

Formula: salt ←$ random, iv ←$ random, dk = PBKDF2(password, salt, 256-bit, SHA-256), cipher = AES-GCM_dk(iv, plaintext). This is an application export format, not a replacement for server-side secrets management.

Ed25519 connection identity

A local keypair gives a stable cryptographic identity without pretending that cryptography can distinguish a human from an automated process.

Proof-of-possession

A fresh challenge is generated for each proof. The local Ed25519 private key signs the challenge and the public key verifies the signature.

challenge ←$ {0,1}^256
signature = Ed25519.Sign(sk, challenge)
valid = Ed25519.Verify(pk, challenge, signature)

Human / bot boundary

An Ed25519 identity proves control of a key, not human presence. SearchXR therefore reports cryptographic identity proof separately from any claim about whether a user is a person or a bot.

QTEL CORE

Quantized Task Execution Layer is the browser-side performance path for CPU work that can safely be moved to a Worker.

Chunk planner

For input size N and target chunk budget C, the planner uses k = ceil(N / C) and c = ceil(N / k). The worker processes chunks without blocking the main UI.

Measured throughput

The core records rate = processedBytes / elapsedSeconds from the actual Worker run rather than showing a fixed benchmark number.

Browser boundary

QTEL does not convert browser JavaScript into arbitrary machine-native instructions. Web Worker execution is still governed by the browser's JS engine, scheduler, and hardware.

RAS CORE

Runtime Assurance Scanner is a local heuristic review pipeline for code that the browser can legitimately read.

source text
   ↓
normalization + byte count
   ↓
pattern checks
   ├─ dynamic code creation (eval / Function)
   ├─ cookie / storage access
   ├─ obfuscated escape density
   ├─ dynamic network / WebSocket usage
   └─ script injection surfaces
   ↓
weighted review score
   ↓
human-readable findings

Project heuristic score: R = min(100, Σ wᵢ·signalᵢ). A finding is a review signal, not a malware verdict. Cross-origin iframe source remains outside the browser-readable security boundary unless the embedded origin exposes it.

Shared Matrix Encoding Layer

A hidden cross-application runtime layer used by SearchXR navigation and worker-capable data paths. It applies a reversible 4×4 permutation-matrix transform plus byte whitening for chunk normalization and transport preparation. It is not a cryptographic primitive; AES-256-GCM remains the security boundary for protected exports.

RUNTIME · SHARED

Encoding formula

For each 16-byte block, bytes are treated as a 4×4 matrix B. The permutation matrix maps P[r,c] = B[(r+c) mod 4,c]. A deterministic whitening byte is then applied per position:

mask(i) = (seed + 31·i + 17·⌊i/16⌋) mod 256
E[i] = P[i] XOR mask(i)
D(P[i]) = E[i] XOR mask(i)
B[(r+c) mod 4,c] = P[r,c]

The transform is deliberately reversible and cheap. It provides block normalization/mixing and a stable byte-level representation for Worker jobs; it does not provide secrecy.

Where the layer is used

Every SearchXR view transition passes a compact event record through the Matrix layer before the local runtime fingerprint is updated.
Worker-capable binary transforms can use the same 16-byte matrix block contract.
QTEL CORE can schedule larger Matrix jobs off the main UI thread.
Module payloads can be fingerprinted consistently without changing module UI contracts.

Cross-device goal: the layer is designed to keep CPU-heavy normalization work small and movable to a Web Worker so desktop and mobile browsers can share the same runtime contract. Actual smoothness still depends on device, browser and workload.

Multi-language implementation contract

The browser build uses JavaScript + Web Worker for the live execution path. Native-language kernels below define the same Matrix contract for future WASM, desktop or mobile shells; this single HTML does not falsely claim that all five native toolchains are compiled into the browser.

Target	Role	Current HTML runtime
C++	Native/WASM reference kernel for byte-level Matrix transforms.	Parity contract; browser fast path remains JS Worker.
Rust	Memory-safe native/WASM parity implementation.	Parity contract; not compiled into this HTML artifact.
Swift	Apple-platform native adaptation of the same block contract.	Parity contract; not executed by the browser page.
Kotlin / Java	Android/JVM adaptation of the same Matrix pipeline and chunk contract.	Parity contract; not executed by the browser page.

Native parity kernels

// C++ / Rust / Swift / Kotlin / Java all implement the same conceptual ABI:
// encode(buffer, length, seed) -> reversible 16-byte Matrix transform.
// decode(buffer, length, seed) -> exact inverse.
// The browser artifact ships the JS Worker implementation now;
// native shells can replace that backend without changing module contracts.

Cache, downloads and error alerts

Security Core keeps a local audit trail for SearchXR actions rather than silently sending activity to an external tracker.

Clear cache

Removes SearchXR local storage, SearchXR-named Cache Storage entries, the local security IndexedDB and applicable SearchXR service-worker registrations. It cannot purge the browser's generic HTTP cache or unrelated site data.

Download index

Records SearchXR-originated download link metadata and browser appinstalled events. It cannot inspect the user's private browser Downloads directory.

Error alert

Runtime errors and unhandled promise rejections are summarized locally with time, category and message so the user can see what failed.

Security reality: client-side code can be inspected by users and browser tooling. SearchXR can protect local data exports and verify cryptographic identity, but it cannot make delivered browser source code permanently invisible to an attacker who controls the browser session.

Stream Module

The SearchXR Stream module is the live playback surface for the supplied Devi Adi Parashakti episode catalogue. It carries the provided episodes directly inside SearchXR in one continuous vertical stream.

STREAM · LIVE PLAYBACK

Purpose

Stream keeps the supplied Devi Adi Parashakti viewing flow inside SearchXR instead of sending the user to a separate page. The module uses the same embedded playback sources supplied in the reference file.

One dedicated SearchXR module named Stream.
Full-width black playback canvas matching the supplied player design.
Episode 1 leads the stream; the remaining episodes continue below it.
Playback is controlled by the embedded source and the user's browser/network.

Playback contract

The integration preserves the supplied player behavior: iframe-based playback, full-width layout, 16:9 episode sizing and a portrait-friendly mobile adapter.

Source boundary: the supplied reference file contains YouTube embed URLs for the episode catalogue. SearchXR does not claim ownership of those hosted videos or bypass the host's playback controls.

Episode catalogue

The Stream module currently carries the 10 episode sources present in the supplied Devi Adi Parashakti source file.

#	Episode	Playback source	Mode
1	Devi Adi Parashakti Full Episode 1 \| देवी आदि पराशक्ति \| Dangal Bhakti	`https://www.youtube.com/embed/0rKhV0p_MUo`	Lead playback
2	Devi Adi Parashakti Full Episode 2	`https://www.youtube.com/embed/Lgcbj8lOOx4?list=TLGGRgIlffHuH4cyODA5MjAyNg`	Continuous stream
3	Devi Adi Parashakti Full Episode 3	`https://www.youtube.com/embed/B2F0-RrZiBM`	Continuous stream
4	Devi Adi Parashakti Full Episode 4	`https://www.youtube.com/embed/GDh_kipC8mc`	Continuous stream
5	Devi Adi Parashakti Full Episode 5	`https://www.youtube.com/embed/f7NkrdaFSR4`	Continuous stream
6	Devi Adi Parashakti Full Episode 6	`https://www.youtube.com/embed/kPjJWbWVtCM`	Continuous stream
7	Devi Adi Parashakti Full Episode 7	`https://www.youtube.com/embed/7O3PfNzJ3xI`	Continuous stream
8	Devi Adi Parashakti Full Episode 8	`https://www.youtube.com/embed/BhuqUpbzOqc`	Continuous stream
9	Devi Adi Parashakti Full Episode 9	`https://www.youtube.com/embed/-VYoGKYyof0`	Continuous stream
10	Devi Adi Parashakti Full Episode 10	`https://www.youtube.com/embed/6iyfc8Jgx4M`	Continuous stream

Responsive stream behavior

The source player is optimized for the same desktop/phone behavior requested for SearchXR modules.

Desktop

The first episode is given a full viewport-height lead frame. Following episodes use a 16:9 viewport-width frame so the entire catalogue can continue vertically.

Mobile

All episode frames use 16:9 sizing on screens up to 768px wide so the supplied Devi Adi Parashakti player remains fully visible without forcing the page wider than the device.

Loading

The first episode is eager-loaded for immediate playback; subsequent episodes use browser lazy loading so the heavy SearchXR host does not request every embedded frame at the same time.

Module data contract

Stream is intentionally simple: a fixed catalogue of supplied embed sources plus UI behavior. No fabricated episode counters, fake live status or synthetic playback data is added.

Operational boundary: episode availability, advertising, region restrictions, playback permissions and network delivery remain controlled by the embedded YouTube source. SearchXR only provides the Stream container and navigation layer.

Infrastructure

Production-oriented hardening for the SearchXR browser surface, with a strict separation between controls that this HTML can actually enforce and controls that must be installed at the hosting, edge or backend layer.

SECURITY · BROWSER + EDGE

RUNTIMECHECKINGHTTPS / Web Crypto / storage audit

EDGEHEADER CONFIGHSTS · CSP · cookie policy · WAF boundary

CRYPTOAES-GCME2EE helper with X25519 when supported, P-256 fallback

What is enforced inside this HTML

These controls are live browser code, not documentation-only claims.

Secure transport guard

Non-local HTTP visits are redirected to HTTPS before the rest of the app is used. This is a client-side guard only; TLS 1.3 and HSTS still belong on the server/edge.

// implemented
if (location.protocol === 'http:' && !/^(localhost|127\.0\.0\.1)$/i.test(location.hostname)) {
  location.replace('https://' + location.host + location.pathname + location.search + location.hash);
}

WSS helper with message authentication

The browser runtime exposes a helper that refuses ws://. The token is sent as the first authenticated message instead of putting a bearer token in the URL.

const ws = await SearchXRSecurity.openWSS('wss://api.example.com/realtime', token);
ws.onmessage = (event) => console.log(event.data);

Browser E2EE helper

Plaintext stays in browser memory, a shared secret is derived from an ephemeral key agreement, and the message is sealed with authenticated AES-256-GCM. The current build prefers X25519 where the browser exposes it and falls back to P-256 ECDH when it does not.

const alice = await SearchXRSecurity.generateE2EEKeyPair();
const bob = await SearchXRSecurity.generateE2EEKeyPair();
const packet = await SearchXRSecurity.sealE2EE(
  alice.privateKey, alice.publicKey, bob.publicKey, 'secret'
);
const clear = await SearchXRSecurity.openE2EE(
  bob.privateKey, alice.publicKey, packet
);

Secret-storage audit

The runtime can inspect storage key names only and flags names that look like passwords, refresh tokens, API keys or private material. It does not print or export the values.

const audit = SearchXRSecurity.auditBrowserStorage();
// { localStorage: [...key names], sessionStorage: [...] }

TLS 1.3 and HSTS

A static HTML file cannot configure the TLS version negotiated by the server. The real control is a hosting/edge configuration.

Netlify/Vercel rule: serve the site only over HTTPS, and add the HSTS response header on the production host. Do not try to fake this with JavaScript or a meta tag.

Strict-Transport-Security: max-age=31536000; includeSubDomains
X-Content-Type-Options: nosniff
Referrer-Policy: strict-origin-when-cross-origin
Permissions-Policy: camera=(), microphone=(), geolocation=(self)
Cross-Origin-Opener-Policy: same-origin-allow-popups

HSTS reality: the browser learns HSTS from an HTTPS response header. A client-side redirect is helpful but does not replace HSTS.

CSP without breaking the existing app

The current artifact contains many inline scripts/styles and several legitimate third-party APIs/iframes. A fully strict nonce/hash CSP therefore needs a build/deploy step rather than an unsafe “CSP meta tag” pasted into this document.

Phase 1 · Report-only

Use the supplied report-only policy at the edge first. It reveals blocked origins in browser console reports without breaking the app.

Content-Security-Policy-Report-Only:
  default-src 'self';
  object-src 'none';
  base-uri 'self';
  frame-ancestors 'self';
  form-action 'self';
  upgrade-insecure-requests;
  script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net;
  style-src 'self' 'unsafe-inline';
  img-src 'self' data: blob: https:;
  media-src 'self' data: blob: https:;
  connect-src 'self' https: wss:;
  worker-src 'self' blob:;
  frame-src 'self' https://www.youtube.com https://*.youtube-nocookie.com https://www.juicer.io https://*.juicer.io https://www.sociablekit.com https://*.sociablekit.com https://www.snapwidget.com https://*.snapwidget.com;

Phase 2 · Strict CSP

After moving inline JavaScript and styles to hashed/nonce-backed assets, remove 'unsafe-inline' and whitelist only the exact origins actually required by the production build.

script-src 'self' 'nonce-...';
style-src 'self' 'nonce-...';
object-src 'none';
base-uri 'self';
frame-ancestors 'self';
form-action 'self';

Subresource Integrity

PeerJS is pinned to an exact version in the current build. The security layer includes a real SRI calculator, but it does not guess a hash. The integrity value must be generated from the exact bytes that will be served.

const sri = await SearchXRSecurity.sriForUrl(
  'https://cdn.jsdelivr.net/npm/peerjs@1.5.4/dist/peerjs.min.js',
  'SHA-384'
);
console.log(sri); // e.g. sha384-BASE64_DIGEST

// Then pin that exact verified value in HTML:
<script src="https://cdn.jsdelivr.net/npm/peerjs@1.5.4/dist/peerjs.min.js"
        integrity="sha384-BASE64_DIGEST"
        crossorigin="anonymous"></script>

Why this is not hard-coded here: SRI is only valid for the exact bytes of the pinned file. An invented or unverified digest would make the app fail closed or, worse, create false confidence. jsDelivr documents the same exact-version requirement for SRI.

Authentication boundary

The current static build has no server login/session system, so JWT rotation and HttpOnly refresh cookies are not pretend-implemented in the browser.

Control	Current build	Production backend
Access token	No persisted auth token is created by Infrastructure.	Short-lived access token; keep lifetime limited.
Refresh token	Not implemented in static HTML.	HttpOnly + Secure + SameSite cookie; rotate on refresh and revoke reuse.
Business rules	Browser UI only.	Validate permissions, pricing, payment and authorization on the server.
API key	Browser code cannot make a shipped secret invisible.	Keep provider secrets on a server/edge function, never in public HTML.

Frontend Zero Trust: anything delivered to a browser can be inspected or modified by the person controlling that browser. Sensitive decisions belong on the backend.

Rate limiting, WAF and DDoS

These are edge/network controls. SearchXR can expose a safe client request helper, but it cannot turn a browser into a WAF.

WAF

Install rules at Cloudflare/your edge or at the origin gateway. Inspect HTTP requests before the application process receives them.

Rate limiting

Rate-limit per IP, identity or API key at the backend/edge. Do not rely on client-side counters because a client can reset them.

DDoS

Use an upstream network/edge mitigation layer for volumetric attacks. A JavaScript function cannot absorb a network flood before packets reach the host.

BGP Anycast edge architecture

Anycast is an infrastructure capability, not a browser feature. A real multi-site anycast service requires globally routable prefixes and BGP announcements from multiple locations; simply placing several VPSs behind one DNS record does not create BGP anycast.

Internet
   ↓
BGP Anycast prefix
   ↓
PoP A ── Go/Rust edge ── origin shard A
PoP B ── Go/Rust edge ── origin shard B
PoP C ── Go/Rust edge ── origin shard C

The browser only sees the public HTTPS hostname. Route control, IP space/ASN, PoP networking, health checks and DDoS filtering live outside this HTML artifact.

Backend runtime, database and memory layers

These are valid production architecture options, but they are not falsely embedded into a browser page.

Requested layer	What a real implementation means	Status in this file
Rust / Go core	Server-side service or gateway compiled and deployed on your infrastructure.	Architecture contract only.
Actor / event loop	Server process with async I/O, bounded worker pools and backpressure.	Not a browser kernel.
Raft cluster	Multiple server nodes with durable logs, quorum and leader election.	Not a single-HTML feature.
Zero-copy	Reduce buffer copies in native/server pipelines where the platform and protocol allow it.	Browser JS cannot promise arbitrary zero-copy memory sharing.
Memory scrubbing	Best-effort zeroing of mutable native buffers; JavaScript strings and garbage-collected objects are not guaranteed to be securely erased.	Documented boundary.

Cryptographic hardening boundary

Do not replace TLS with a custom handshake. Use TLS 1.3 for transport security and standard, audited libraries when the application layer needs additional end-to-end encryption.

Implemented recommendation

HTTPS for page transport.
Web Crypto AES-GCM for authenticated encryption.
X25519 when exposed by the browser; P-256 fallback.
Ed25519 proof-of-possession already present in Security Core.
No password, token or private key written into LocalStorage by the new hardening runtime.

Not falsely claimed

Custom ChaCha20-Poly1305 implementation is not added to this HTML.
Custom TLS replacement handshake is not added.
BGP/Anycast is not simulated in browser JavaScript.
WAF/DDoS mitigation is not simulated with client-side code.

Reason: browser security primitives and audited transport protocols should be used instead of inventing a new cryptographic protocol inside a static page.

Deployment checklist

This single HTML file contains the browser runtime plus the exact Netlify/Vercel header configuration below as copy-ready deployment references. Headers still have to be applied by the host; HTML cannot install response headers by itself.

1. HTTPS only
2. HSTS response header
3. CSP Report-Only → inspect → strict CSP
4. Pin third-party assets and add verified SRI
5. No secrets in browser storage
6. HttpOnly/Secure/SameSite auth cookies on backend
7. Short-lived access tokens + refresh rotation on backend
8. WAF + edge rate limiting
9. Server-side authorization/business rules
10. Monitor errors and rotate compromised credentials quickly

Netlify · embedded headers reference

Copy this block into a root-level _headers file when deploying the same HTML on Netlify.

/*
Strict-Transport-Security: max-age=31536000; includeSubDomains
X-Content-Type-Options: nosniff
Referrer-Policy: strict-origin-when-cross-origin
Permissions-Policy: camera=(), microphone=(), geolocation=(self)
Cross-Origin-Opener-Policy: same-origin-allow-popups
Content-Security-Policy-Report-Only: default-src 'self'; object-src 'none'; base-uri 'self'; frame-ancestors 'self'; form-action 'self'; upgrade-insecure-requests; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: https:; media-src 'self' data: blob: https:; connect-src 'self' https: wss:; worker-src 'self' blob:; frame-src 'self' https://www.youtube.com https://*.youtube-nocookie.com https://www.juicer.io https://*.juicer.io https://www.sociablekit.com https://*.sociablekit.com https://www.snapwidget.com https://*.snapwidget.com
*/

Vercel · embedded headers reference

Copy this object into vercel.json when deploying the same HTML on Vercel.

{
  "headers": [
    {
      "source": "/(.*)",
      "headers": [
        {"key":"Strict-Transport-Security","value":"max-age=31536000; includeSubDomains"},
        {"key":"X-Content-Type-Options","value":"nosniff"},
        {"key":"Referrer-Policy","value":"strict-origin-when-cross-origin"},
        {"key":"Permissions-Policy","value":"camera=(), microphone=(), geolocation=(self)"},
        {"key":"Cross-Origin-Opener-Policy","value":"same-origin-allow-popups"},
        {"key":"Content-Security-Policy-Report-Only","value":"default-src 'self'; object-src 'none'; base-uri 'self'; frame-ancestors 'self'; form-action 'self'; upgrade-insecure-requests; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: https:; media-src 'self' data: blob: https:; connect-src 'self' https: wss:; worker-src 'self' blob:; frame-src 'self' https://www.youtube.com https://*.youtube-nocookie.com https://www.juicer.io https://*.juicer.io https://www.sociablekit.com https://*.sociablekit.com https://www.snapwidget.com https://*.snapwidget.com"}
      ]
    }
  ]
}

Single-file boundary: keeping the config inside this HTML makes the reference portable, but it does not magically make Netlify/Vercel read it. The host configuration must still be created outside the HTML at deployment time.

Terms · Policy · Code Rules

This page defines the mandatory operating rules for X-Star Collection, SearchXR modules, bundled application systems, contributors and future integrations. These rules are designed for a high-trust, security-first, performance-aware browser ecosystem.

Policy notice: These are product and engineering rules for the collection; they are not a substitute for legal advice, provider agreements or jurisdiction-specific compliance requirements.

GOVERNANCE · STRICT MODE

POLICY VERSION1.0.0Collection governance baseline

DEFAULT MODEDENY-FIRSTUnknown or unsafe operations must fail closed

SECURITY MODELZERO TRUSTBrowser, network, provider and backend boundaries are treated independently

1 · Terms of Use

Use of this collection and its bundled tools must remain lawful, respectful of user privacy, and consistent with upstream provider terms.

Lawful use only. Do not use X-Star Collection, SearchXR or any bundled module for malware, credential theft, unauthorized access, fraud, harassment, evasion of security controls, or unlawful surveillance.
Respect upstream services. Do not bypass authentication, rate limits, robots policies, paywalls, access controls, or platform restrictions of third-party services.
Respect privacy. Do not collect, expose, infer, or redistribute private or sensitive information without a lawful basis and appropriate authorization.
Respect content rights. Search, feed, image, music, video and social results may remain controlled by their upstream providers and rights holders.
Protect credentials. API keys and tokens supplied by a user remain the user's responsibility. Never commit, publish, log, or bundle secrets into source control or public HTML.
No destructive automation. Automation must not send uncontrolled floods of requests, repeatedly retry failures without bounds, or intentionally degrade a provider or host.
No false guarantees. Browser-side code may provide safeguards, but server-side authorization, TLS, WAF, HSTS, rate limiting and secret storage must be enforced at the infrastructure boundary.

2 · Strict Security Rules

The following rules are mandatory for new code and should be treated as release blockers when violated.

Secrets rule

Never hard-code API keys, private keys, refresh tokens, session cookies or provider credentials in source. Store temporary browser credentials in memory/session scope only when a direct browser call is intentionally supported; prefer a backend/edge proxy for production secrets.

Network rule

Prefer HTTPS and WSS. Validate target URLs before requests. Use an explicit host allowlist for sensitive integrations. Every request must have a timeout, cancellation path and bounded retry behavior.

Injection rule

Never insert untrusted provider text as executable HTML. Prefer textContent, DOM APIs and safe templates. When rich HTML is unavoidable, sanitize against an explicit allowlist and remove scripts, event-handler attributes and dangerous URLs.

Frame rule

Third-party frames must use an explicit allowlist and the narrowest practical permissions. Do not treat an iframe boundary as a security authorization boundary for secrets or privileged operations.

Data rule

Minimize collected data. Do not store provider payloads, access tokens or user-sensitive information longer than required. Never put secrets into analytics, event logs, URLs or error messages.

Failure rule

Unknown states must fail closed. Do not silently fall back to unsafe protocols, arbitrary origins, unrestricted redirects, uncontrolled retries or privileged actions.

3 · Developer Code Guidelines

Every new module should follow these rules before it is accepted into the collection.

Area	Required rule	Release expectation
JavaScript	Use strict mode; prefer small pure functions; avoid `eval`, `new Function` and dynamic script injection.	Static review + runtime smoke test
DOM	Use `textContent` and DOM methods for untrusted values; sanitize any rich provider-controlled HTML.	No known DOM-XSS sink from external input
Networking	Use `AbortController`, request deadlines, bounded response sizes, concurrency limits and backoff.	No hanging request path
Dependencies	Pin versions; avoid floating CDN versions; use SRI for critical external scripts where practical.	Version + integrity recorded
Frames	Allowlist origins; apply sandbox/permission restrictions when compatible with the embedded application.	Origin reviewed
Storage	Namespace storage keys; never persist secrets unless the threat model explicitly allows it.	Storage audit passes
Performance	Lazy-load heavy assets, virtualize large lists where possible, cancel stale searches, and keep CPU-heavy transforms off the main thread.	Mobile degradation documented
Observability	Log structured, non-sensitive events; never log tokens or private payloads.	Errors actionable and redacted

4 · Runtime Enforcement Layer

The following browser-side policy engine is included to give future modules common validation, request deadlines, response limits, host checks, rate limiting, safe URL handling and redacted audit events. It is a reusable enforcement API; modules should call it instead of duplicating ad-hoc security code.

Safe network contract

await XStarPolicy.fetch('https://api.example.com/data', {
  timeoutMs: 15000,
  maxBytes: 2 * 1024 * 1024,
  retry: 2
});

XStarPolicy.allowHost('api.example.com');

Safe redirect contract

const url = XStarPolicy.safeUrl(userInput, {
  protocols: ['https:'],
  hosts: ['example.com', '*.examplecdn.com']
});

XStarPolicy.open(url, '_blank');

Rate gate

Per-action budgets prevent accidental request floods inside supported modules.

Payload guard

Response bodies are bounded where the browser can enforce a safe byte budget.

Audit trail

Security events are timestamped and redacted before session-scoped diagnostic storage.

5 · Release Gates

A module is not ready for collection release until all applicable gates pass.

Security: no known secret exposure, unsafe redirect, uncontrolled privileged action, or obvious injection sink.
Network: all external origins are identified; timeouts, aborts and bounded retries exist.
Performance: heavy work is lazy, stale requests are cancelled, and mobile limitations are documented.
Integrity: bundled source identity/hash is recorded when exact preservation matters.
Policy: third-party terms and content rights are not intentionally bypassed.
Recovery: loading, empty, error and offline/blocked states are explicit and reversible.

Important security boundary: this browser policy engine improves client-side safety and consistency, but it cannot make a static HTML file tamper-proof. Production authorization, secret protection, WAF/rate limits, HSTS, strict CSP headers and server-side validation must remain enforced at the deployment boundary.

Performance & Device Requirements

SearchXR is primarily designed for desktop and PC-class processors. The full application combines multiple browser modules, large bundled assets, image and media rendering, embedded environments, Web Workers and live network requests. On lower-powered phones, the same workload can cause slower rendering, higher memory pressure, heat or visible lag.

PERFORMANCE · DESKTOP FIRST

PRIMARY TARGETPC / DESKTOPBest experience for the full SearchXR collection and heavier modules

MOBILEBEST-EFFORTPhone browsers can run the app, but complex modules may lag

HEAVY WORKLOADSMEDIA + IFRAMESImages, video, embedded apps and network fetches can increase CPU/RAM use

Why phones can lag

The Collection contains several independently functional browser environments. When multiple heavy surfaces are active, browser scheduling, memory limits and thermal constraints become the main performance boundary.

Processor and memory load

Large single-file HTML payloads increase initial parsing and memory work.
Image masonry, artwork, thumbnails and video frames require repeated decode and render operations.
Embedded iframes and bundled applications may continue their own JavaScript and network activity.
Web Workers move some work off the UI thread, but they still consume device CPU resources.

Mobile boundary

Phone support is responsive, not a guarantee of desktop-level performance. On entry-level or thermally constrained phones, users may see slower scrolling, delayed module startup, dropped frames or delayed network results. This is an expected resource boundary of the full application.

Recommended operating pattern

For the smoothest experience, use SearchXR on a modern desktop or laptop and avoid opening several media-heavy modules at the same time. On phones, prefer the lighter Search, Music and Image surfaces first and open heavier embedded modules only when needed.

Design rule: SearchXR remains responsive across screen sizes, but the full Collection is optimized around desktop-class processor and memory availability. Responsive layout does not reduce the computational cost of every module.

Search. See. Listen.

Search

Image

Music

Workspace

Explainer

Shared memory

How can I helpyou today?

The XR Developer Layer.

Platform at a glance

What developers get

Reality boundary

Stable surface

Getting Started

Install by file

First command

Download the same SDK source

Core Concepts

Runtime

Command

Event

State model

Result contract

SDK

Lifecycle

Core API

Transport

API Reference

HTTP Client

GET

POST JSON

Transport behavior

Events & Plugins

Subscribe

Plugin pattern

Reserved topics

Architecture

01 · Interface

02 · Runtime

03 · Services

Reference request path

Isolation guarantee

Insights & Metrics

Capability mix

Runtime flow

Reference delivery trend

Reference matrix

Data Contracts

Manifest

Failure envelope

Contract principles

Security

Secrets

Authorization

Validation

Production checklist

Errors & Reliability

Retry policy

Observability

Examples

Complete mini application

Command-driven UI

Testing

Changelog

Compatibility policy

Leadership & Founder

SearchXR

X-Star Community

Leadership

Ecosystem model

Attribution rule

VeoXR Module

What VeoXR is for

Primary connection

Clarity boundary

Current implementation

Source and isolation contract

Source integrity

Host isolation

Navigation integrity

How can I help
you today?