import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"; import { join, resolve } from "node:path"; import { format } from "prettier"; const root = resolve(import.meta.dir, ".."); const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8")); const version = pkg.wrnexus.version as string; const pages = join(root, "app", "pages"); const docs = join(root, "docs"); const pub = join(root, "public"); mkdirSync(docs, { recursive: true }); const packageNames = [...Object.keys(pkg.dependencies), ...Object.keys(pkg.devDependencies)] .filter((name) => name.startsWith("@wrnexus/")) .map((name) => name.split("/")[1]!) .filter((name, index, all) => all.indexOf(name) === index) .sort(); const packageCount = packageNames.length; const uiReferencePath = join(root, "node_modules", "@wrnexus", "ui", "component-reference.json"); const uiReference = existsSync(uiReferencePath) ? (JSON.parse(readFileSync(uiReferencePath, "utf8")) as { count: number; components: Array<{ name: string; mount: string; category: string; props: Array<{ name: string; type: string; required: boolean; default: string | null }>; slots: string[]; events: string[]; }>; }) : undefined; const uiReferenceText = uiReference ? uiReference.components .map( (component) => `### ${component.name}\nMount: data-component="${component.mount}"\nCategory: ${component.category}\nProps: ${component.props.length ? component.props.map((prop) => `${prop.name}: ${prop.type}${prop.required ? " (required)" : ` = ${prop.default}`}`).join(", ") : "none"}\nSlots: ${component.slots.join(", ") || "none"}\nEvents: ${component.events.join(", ") || "none"}`, ) .join("\n\n") : "UI component reference unavailable; install the release-aligned @wrnexus/ui package."; async function writeFormatted(path: string, source: string) { writeFileSync(path, await format(source, { filepath: path })); } const esc = (s: string) => s.replaceAll("{", "{").replaceAll("}", "}"); const code = (s: string) => `
${esc(s).replaceAll("<", "<").replaceAll(">", ">")}
`; const navigation = [ ["/getting-started", "Get started"], ["/packages", "Packages"], ["/language", "Language"], ["/architecture", "Architecture"], ] as const; const documentationNavigation = [ ...navigation, ["/tutorial", "Tutorial"], ["/guides/project-structure", "Guides"], ["/examples", "Examples"], ["/search", "Search"], ] as const; function shell(title: string, description: string, body: string, section = "Documentation") { const nav = navigation.map(([href, label]) => `${label}`).join(""); const mobileNav = documentationNavigation .map(([href, label]) => `${label}`) .join(""); const breadcrumbs = title === "Home" ? "" : ``; return `page ${title.replace(/[^A-Za-z0-9]/g, "") || "Guide"} { seo { title = "${title.replaceAll('"', "'")}" description = "${description.replaceAll('"', "'")}" canonical = "https://wrnexusjs.dev${routeFor(title)}" } view {
W WRNexusJS
Preview · v${version}
Browse documentation
${breadcrumbs}${body}
} }`; } function marketingShell(description: string, body: string) { const codeCard = `
app/pages/dashboard.wrn
page Dashboard {
  ssr { api tasks GET /api/tasks { return tasks } }
  view {
    <main>
      <h1>Tasks</h1>
      {#each tasks as task}
        <article>{task.title}</article>
      {:empty}
        <p>Nothing waiting.</p>
      {/each}
    </main>
  }
}
`; const marketingBody = body .replace("hero portal-hero", "hero marketing-hero") .replace( "Packages require approved private-registry access. No public installation command is currently available.", "Private developer preview. Request access to the package registry.", ) .replace("", `${codeCard}`); return `page Home { seo { title = "WRNexusJS — Bun-native server-first framework" description = "${description.replaceAll('"', "'")}" canonical = "https://wrnexusjs.dev/" } view {
W WRNexusJS
Private preview · v${version}
Menu
${marketingBody}
} }`; } const slugs: Record = { Home: "", Packages: "/packages", "Getting started": "/getting-started", Tutorial: "/tutorial", Architecture: "/architecture", "The .wrn language": "/language", }; function routeFor(title: string) { return ( slugs[title] ?? `/${title .toLowerCase() .replace(/[^a-z0-9]+/g, "-") .replace(/^-|-$/g, "")}` ); } function page(route: string, title: string, description: string, body: string, section?: string) { const path = route === "/" ? join(pages, "index.wrn") : join(pages, `${route.slice(1)}.wrn`); mkdirSync(resolve(path, ".."), { recursive: true }); slugs[title] = route; writeFileSync(path, shell(title, description, body, section)); } const status = ` Private Developer Preview`; writeFileSync( join(pages, "index.wrn"), marketingShell( "WRNexusJS is a Bun-native, SSR-first full-stack framework using the .wrn component language.", `
${status}

WRNexusJS v${version}

Build from the server.
Ship only what matters.

WRNexusJS is an SSR-first, Bun-native full-stack framework. Build typed pages, APIs, validated forms, realtime rooms, secure sessions, workspaces, and optional mobile experiences with the .wrn component language.

Request preview accessRead the preview docs

Packages require approved private-registry access. No public installation command is currently available.

Why WRNexusJS

Server-first rendering

Useful HTML is rendered first; reactive scopes hydrate only where declared.

.wrn components

Pages, layouts, props, state, events, server loops, and directives live in a focused language.

Bun-native runtime

The runtime is Bun. Node compatibility is not claimed.

Typed data and validation

Database queries and shared validation connect server routes to forms.

Integrated security

CSP, CSRF, sessions, authorization, encryption, and safe output are framework primitives.

Realtime and workspaces

Rooms, Redis pub/sub, and multi-app gateways support live and isolated applications.

A small full-stack flow

${code(`// app/schemas/contact.ts\nimport { v } from "@wrnexus/validation";\nexport default v.object({ email: v.string().email(), message: v.string().min(10) });\n\n// app/api/contacts.ts\nimport schema from "../schemas/contact";\nimport { parseBody } from "@wrnexus/validation";\nexport const POST = async (ctx) => {\n const result = await parseBody(schema, ctx.req);\n return result.ok ? Response.json({ ok: true }, { status: 201 }) : result.response;\n};`)}

Request lifecycle

  1. RequestSecurity headers and request limits
  2. MiddlewareAuthentication, policy, and context
  3. File routePage or API handler
  4. Compiler + SSRSafe HTML and scoped runtime
  5. ResponseHTML, JSON, stream, or realtime upgrade

Production proof

WorkRoot

Public creator/company site and approved WRNexusJS production showcase.

wrnexusjs.dev

This documentation application runs WRNexusJS ${version}.

View deployment notes and showcase status →

Capability status

CapabilityStatusDetails
SSR, routing, compiler, APIsPreviewInstalled in ${version}; public support policy pending.
Mobile/nativeExperimentalCapacitor compatibility and native generation have platform limitations.
Durable queuesExperimentalProduction durability requires an appropriate driver strategy.

Continue exploring

Explore ${packageCount} packagesRelease notesRoadmapSupport and access
`, ), ); page( "/access", "Access", "Request access to the WRNexusJS private developer preview.", `
${status}

Request preview access

WRNexusJS ${version} packages are not available from the public npm registry. Installation requires approval and private registry credentials supplied by WorkRoot. Never paste registry tokens into source control, issue reports, or support messages.

Request process

  1. Contact WorkRoot through the public contact path at workroot.in.
  2. Describe the application, team, expected deployment, and Bun environment.
  3. After approval, follow the registry instructions supplied privately.
  4. Use the canonical scaffold command below only after authentication.
${code(`bunx @wrnexus/cli@${version} create my-app`)}

Access approval, response time, licensing terms, and support level remain owner-controlled. This site does not collect access requests directly.

`, "Status", ); page( "/getting-started", "Getting started", "Build and run a first WRNexusJS application after receiving private preview access.", `
Preview guide · v${version}

Build a contact inbox

This path creates a server-rendered page, validated API route, middleware, and realtime next step. It requires approved registry access and Bun 1.3.x; this site was verified with Bun 1.3.14.

1. Create the project

${code(`bunx @wrnexus/cli@${version} create my-app\ncd my-app\nbun install\nbun run dev`)}

2. Know the structure

${code(`app/pages/ # file-based .wrn routes\napp/components/ # reusable .wrn components\napp/api/ # TypeScript request handlers\napp/middleware/ # ordered request middleware\napp/schemas/ # shared validation\napp/realtime/ # realtime rooms\nwrnexus.config.ts`)}

3. Add a page

${code(`page Contacts {\n view {\n

Contact inbox

\n
\n \n \n \n
\n
\n }\n}`)}

4. Validate an API route

${code(`import schema from "../schemas/contact";\nimport { parseBody } from "@wrnexus/validation";\nexport const POST = async (ctx) => {\n const result = await parseBody(schema, ctx.req);\n return result.ok ? Response.json({ ok: true }, { status: 201 }) : result.response;\n};`)}

5. Load server data

Use an ssr API binding and a server {#each} block. See Server data for the complete verified pattern.

6. Add middleware

${code(`export default async function logger(ctx, next) {\n console.log(ctx.req.method, ctx.url.pathname);\n return next();\n}`)}

7. Test and ship

${code(`bun run test\nbun run build\nbun dist/server.js`)}

Next: deployment, database, authentication, and workspaces.

`, ); page( "/tutorial", "Tutorial", "Build a secure task application with WRNexusJS preview APIs.", `
Preview · runnable-project extraction pending

Secure task board

This tutorial connects the installed ${version} APIs into one design. Snippets are limited to declarations and README patterns verified in the installed packages; a CI-compiled standalone fixture remains on the roadmap.

Application shape

A .wrn page renders tasks from an SSR API binding. A shared validation schema protects mutations. Session middleware identifies users, authorization policies gate updates, and a realtime room broadcasts changes.

Schema and create route

${code(`import { v, parseBody } from "@wrnexus/validation";\nconst task = v.object({ title: v.string().trim().min(3).max(120) });\nexport const POST = async (ctx) => {\n const parsed = await parseBody(task, ctx.req);\n if (!parsed.ok) return parsed.response;\n return Response.json({ ok: true, task: parsed.value }, { status: 201 });\n};`)}

Server-rendered list

${code(`page Tasks {\n ssr { api tasks GET /api/tasks { return tasks } }\n view {\n

Tasks

    \n {#each tasks as task}
  • {task.title}
    • {:empty}
  • No tasks yet.
    • {/each}\n
\n }\n}`)}

Production checklist

Follow the focused database, authentication, authorization, realtime, and upload guides.

`, ); page( "/architecture", "Architecture", "WRNexusJS request lifecycle, compiler, runtime, security, data, realtime, workspace, deployment, and mobile architecture.", `
Framework architecture · ${version}

Architecture

WRNexusJS is Bun-native and SSR-first. File discovery maps pages and API handlers; middleware enriches or short-circuits a request; the compiler turns .wrn declarations into server render functions and small feature runtimes.

Request and build lifecycle

  1. DiscoverPages, APIs, middleware, components, layouts, schemas, rooms
  2. CompileParse .wrn, validate grammar, generate server code
  3. RequestLimits, security, locale, session, middleware
  4. MatchStatic and dynamic file route
  5. RenderSSR data, escaped interpolation, components, metadata
  6. EnhanceOnly required reactive/directive runtimes

Package boundaries

core owns contexts, middleware, sessions and rooms; router discovers routes; compiler parses .wrn; ssr renders documents; csr supplies browser runtimes; dev-server and cli orchestrate development and builds.

Security and data flow

Validation happens at trust boundaries. Session authentication establishes identity; authorization makes resource decisions. CSP, Trusted Types, CSRF, upload checks, WebSocket origins, request limits, and output escaping are layered controls—not substitutes for application policy.

Realtime and scale

Rooms are process-local unless connected through pub/sub. Redis-backed pub/sub distributes events. Queue durability depends on the selected driver and must be evaluated explicitly.

Workspaces and gateways

The gateway can dispatch multiple applications while preserving route, component, asset, config, and session boundaries. Validate host routing and isolation before production.

Build and deployment

wrnexus build . produces dist/server.js and hashed/static assets. Run the server with Bun, apply migrations before traffic, terminate TLS at a trusted edge, and forward only expected proxy headers.

Mobile

Mobile compatibility bridges SSR-safe Capacitor capabilities; native route generation is experimental and is not general web portability. Test each target platform.

Generated files and limits

app/routes.gen.ts, .wrnexus/, and dist/ are generated. The runtime is Bun-only. Preview packages are private. Historical compatibility and long-term support policy are not yet published.

`, ); page( "/language", "The .wrn language", "Reference for WRNexusJS .wrn pages, components, layouts, props, state, directives, forms, security, and errors.", `
Language reference · ${version}

The .wrn language

File anatomy

${code(`page Account {\n layout = "public"\n seo { title = "Account" description = "Manage your account." }\n state count = 0\n view { }\n}`)}

Pages, components, layouts, props, and state

Pages are routes. Components declare default-valued props and may hold state. Layouts provide shared slots. Mount components with data-component; fill default or named slots with data-slot.

Interpolation, conditionals, and loops

Interpolation is HTML-escaped. Use server {#if} and {#each} for SSR data. Use data-show for reactive client visibility.

Events and directives

@click and other events execute in the reactive scope. Data attributes opt into forms, i18n, themes, realtime, uploader, browser, and mobile behavior. Consult the exact package page because availability varies.

Forms, i18n, themes, and realtime

form[data-schema] connects descriptors to client and server validation. Translation keys use {t:key}. Theme toggles use data-wire-theme-toggle. Realtime pages opt into a named room.

Escaping and security

Text interpolation is escaped by default. Do not construct trusted HTML from user input. Server-only refinements must be repeated at the authoritative mutation boundary.

Common compiler errors

`, ); const guides: Record = { "project-structure": [ "Project structure", "How source, public, generated, and build files are organized.", "Pages, components, layouts, APIs, middleware, schemas, database files, locales, realtime rooms, and styles live under app. Never edit app/routes.gen.ts, .wrnexus, or dist by hand.", ], routing: [ "Routing", "File-based page and API routing.", "A page filename defines its URL; index maps to the directory root and bracket segments are dynamic parameters. API files under app/api expose HTTP method functions and receive a Context.", ], "pages-and-components": [ "Pages and components", "Compose .wrn pages, layouts, props, state, and slots.", "Pages are routable, components are reusable, and layouts provide shared slots. Mount a component with data-component and keep browser state scoped and minimal.", ], "server-data": [ "Server data", "Render API-backed data with SSR bindings.", "Use an ssr API binding, return the desired response field, and render it with a server #each block. Values are escaped. Avoid fetching private data through a route that lacks authorization.", ], "api-routes": [ "API routes", "Build typed Bun-native HTTP handlers.", "Export GET, POST, PUT, PATCH, or DELETE from app/api files. Validate request bodies, enforce authentication and authorization, cap request sizes, and return Web Responses.", ], middleware: [ "Middleware", "Order and short-circuit request middleware.", "Middleware receives context and next. Return next() to continue or return a Response to stop. Put request limits and trust-boundary controls before business logic.", ], "forms-and-validation": [ "Forms and validation", "Share validation between forms and API routes.", "Define a v.object schema, use data-schema on the form, show field errors with data-error, and always call parseBody on the server. refine is server-only.", ], authentication: [ "Authentication", "Session and identity boundaries.", "Configure session authentication, log users in through supported auth helpers, and read identity from context. Cookie flags, rotation, expiry, and secret storage remain deployment responsibilities.", ], authorization: [ "Authorization", "Roles, permissions, policies, and resource checks.", "Authentication identifies; authorization decides. Enforce permissions in server routes and policies, including object ownership. UI hiding is never an authorization boundary.", ], security: [ "Application security", "Configure layered WRNexusJS security controls.", "Use CSP, CSRF, Trusted Types, session hardening, validation, origin checks, upload restrictions, encryption, request limits, and explicit CORS. See the security policy for reporting.", ], database: [ "Database", "Drivers, models, typed SQL, migrations, and deployment.", "Configure SQLite or the installed supported driver, keep queries in named SQL blocks, generate typed functions, and apply migrations before traffic. Back up data and test rollback independently.", ], uploads: [ "Uploads", "Validated local and S3-compatible file handling.", "Configure named stores, accepted MIME/extensions, and maxBytes. Random keys avoid path traversal. Private files require an authenticated serving route; v1 buffers each file in memory.", ], realtime: [ "Realtime", "Define rooms and secure WebSocket traffic.", "defineRoom handles connection and messages. Validate message shapes, authorize subscriptions, restrict origins, bound payloads, and use pub/sub to scale across processes.", ], pubsub: [ "Pub/sub", "Scale events with in-process or Redis-backed pub/sub.", "The in-process driver cannot cross processes. Use Redis where instances must share events, define channel ownership, and design for reconnects and duplicate delivery.", ], queues: [ "Queues", "Run delayed, retried, and repeated jobs.", "Queue behavior is preview-level. Treat in-process work as non-durable, make handlers idempotent, cap retries, record failures, and choose a production persistence strategy.", ], testing: [ "Testing", "Test compiled components, routes, and browser behavior.", "Use Bun tests and @wrnexus/test helpers. Cover server HTML, API status and validation, authorization failures, reactive behavior, and a production startup smoke test.", ], "workspaces-and-gateway": [ "Workspaces and gateway", "Add applications, route domains, and implement safe SSO forward authentication.", `

A workspace runs isolated applications behind one domain-routing gateway. Add an application from the workspace root; the CLI scaffolds apps/reports and registers it in wrnexus.workspace.ts:

${code(`wrnexus workspace add reports --domain=reports.localhost bun install bun run dev`)}

Forward authentication

Point protected applications at a dedicated verifier endpoint. The verifier must return 2xx for an authenticated session, 401/403 to deny access, or an HTTP redirect to begin browser login.

${code(`// wrnexus.workspace.ts { name: "admin", dir: "apps/admin", domains: ["admin.localhost"], auth: { forward: { url: "http://sso.localhost:3000/api/verify" } }, }`)}

The gateway forwards cookies, authorization, original host, protocol, method, path, and query. Inside the verifier, ctx.url identifies the SSO verifier request—not the original admin URL. Use @wrnexus/helpers to reconstruct and validate the original destination:

${code(`import type { Context } from "@wrnexus/core"; import { redirectToLogin } from "@wrnexus/helpers"; export const GET = async (ctx: Context) => { if (await hasValidSession(ctx)) { return new Response(null, { status: 204 }); } return redirectToLogin(ctx, "/login", { allowedHosts: ["admin.localhost:3000", "reports.localhost:3000"], }); };`)}

Always allowlist redirect hosts. After login, validate or sign the returnTo value before redirecting. Keep internal app ports private and open applications through the gateway port.

`, ], deployment: [ "Deployment", "Build and run WRNexusJS with Bun.", "Run bun run build, apply migrations, and start dist/server.js with Bun. Configure TLS, proxy trust, environment validation, health checks, graceful restarts, logs, backups, and restrictive security headers.", ], "configuration-and-profiles": [ "Configuration and profiles", "Use typed config and environment-specific profiles.", "wrnexus.config.ts owns styles, SEO, security, data, mobile, fonts, and profiles. Keep secrets in validated environment variables and review merged production configuration.", ], "i18n-and-themes": [ "Internationalization and themes", "Load translations and token-based themes.", "Store locale JSON under app/locales and use translation directives. Themes resolve CSS tokens; ensure contrast, system preference behavior, persistence, and non-color cues.", ], mobile: [ "Mobile", "Understand experimental webview and native modes.", "Mobile capabilities are experimental in this preview. Test Capacitor permissions and lifecycle on each platform; do not assume every .wrn or browser API converts to native.", ], observability: [ "Observability", "Capture errors and events without leaking private data.", "Use tracking middleware and sinks with redaction, sampling, stable request identifiers, alert ownership, and retention limits. Never capture registry tokens or session secrets.", ], upgrading: [ "Upgrading", "Upgrade aligned WRNexusJS packages safely.", `Back up and commit first, then use wrnexus update --latest as documented by the installed CLI. Review migrations and keep every @wrnexus package aligned. Current release: ${version}.`, ], troubleshooting: [ "Troubleshooting", "Diagnose compiler, routing, build, and runtime failures.", "Confirm Bun and package versions, regenerate docs/routes through supported commands, read the first compiler diagnostic, check file naming, validate config, and reproduce under a production build.", ], }; for (const [slug, [title, desc, text]] of Object.entries(guides)) page( `/guides/${slug}`, title, desc, `
Preview guide · ${version}

${title}

${text.startsWith("<") ? text : `

${text}

`}

Release scope

This guide describes installed ${version} capabilities. Follow linked package declarations for exact signatures; undocumented behavior is not guaranteed.

Browse package APIs · Troubleshooting · Support

`, "Guides", ); const examples = [ "Minimal .wrn page", "Database CRUD", "Authentication and protected route", "Permissions", "Forms and validation", "Realtime dashboard", "File upload", "Background queue", "Redis pub/sub", "Workspace gateway", "Deployment", "Experimental mobile mode", ]; page( "/examples", "Examples", "WRNexusJS examples and their verification status.", `

Examples

Examples are tied to installed ${version} package documentation. The focused snippets in guides are source-verified; standalone runnable projects and CI compilation are tracked as remaining work.

${examples.map((x, i) => `

${x}

${i === 0 || i === 4 ? "Documented" : "Planned fixture"}
`).join("")}
`, "Learn", ); page( "/showcase", "Showcase", "Approved public WRNexusJS deployments.", `

Showcase

Only confirmed public properties are listed; no customer or traffic claims are made.

WorkRoot

Creator/company site demonstrating a public WRNexusJS deployment. Exact deployed version and infrastructure notes await owner confirmation.

WRNexusJS docs

This documentation portal, built and verified against WRNexusJS ${version} on Bun.

Screenshots are intentionally deferred until approved assets and alt text are available.

`, "Project", ); page( "/benchmarks", "Benchmarks", "Reproducible WRNexusJS performance evidence and methodology status.", `

Benchmarks

No publishable benchmark dataset yet

No comparative speed claims are published. A valid baseline must record scripts, commit, Bun/framework versions, hardware, OS, warmup, samples, workload, raw results, median, percentiles, memory, HTML size, browser JavaScript size, and run date.

The roadmap starts with WRNexusJS-only measurements before any maintained equivalent-workload comparison.

`, "Project", ); page( "/roadmap", "Roadmap", "Current WRNexusJS documentation and framework priorities without promised dates.", `

Roadmap

Roadmap items are direction, not delivery commitments. Dates require explicit owner approval.

Now

  • Private preview onboarding and accurate package references
  • Runnable documentation fixtures and link/accessibility checks
  • License, support, and disclosure owner decisions

Next

  • Durable queue driver guidance
  • Expanded database/auth/realtime examples
  • Versioned release notes and migration fixtures

Later / exploration

  • Historical documentation selector
  • Maintained reproducible benchmarks
  • Broader mobile/native coverage
`, "Project", ); page( "/changelog", "Changelog", "WRNexusJS documentation release history and migration notes.", `

Changelog

${version} 2026-07-13

Documentation is aligned to all ${packageCount} installed packages. This release adds @wrnexus/helpers, original-request URL helpers, safe login redirects, working wrnexus workspace add, and forward-auth redirect propagation.

Migration notes

Run wrnexus update --latest and keep every @wrnexus/* package on ${version}. Existing applications must explicitly add @wrnexus/helpers before importing it; newly scaffolded applications include it automatically.

Versioning and support

The packages use semantic-looking versions, but a formal compatibility and old-release support policy has not been approved. Preview consumers should treat minor releases as potentially requiring migration review.

`, "Project", ); page( `/releases/${version}`, `Release ${version}`, `WRNexusJS ${version} release notes.`, `

WRNexusJS ${version}

Released 2026-07-13. All ${packageCount} installed packages are aligned to this version. Highlights include the new helpers package, reliable workspace app addition, and browser SSO redirects through forward authentication. See the changelog, upgrade guide, and package references.

`, "Releases", ); page( "/security", "Security", "WRNexusJS security defaults, limits, supported release status, and reporting process.", `

Security

WRNexusJS provides primitives for CSP, CSRF, Trusted Types, sessions, validation, authorization, encryption, upload restrictions, request limits, and WebSocket-origin checks. Applications remain responsible for correct configuration, business authorization, secrets, dependencies, data protection, and operations.

Supported releases

Only the current private-preview release ${version} is documented here. A formal old-release support window is not yet published.

Report a vulnerability

Use WorkRoot’s approved private contact path at workroot.in. Do not publish exploit details or secrets. Include affected version, impact, reproduction, and a safe contact method. Response targets, encryption key, bounty, audit, and certification are not currently claimed.

Deployment controls

Use restrictive CSP and permissions policies, HSTS only on HTTPS production origins, MIME sniffing protection, restrictive referrers, explicit CORS, secure cookies, CSRF validation, request limits, and origin checks. See application security.

`, "Trust", ); page( "/support", "Support", "Actual WRNexusJS private preview support and contact routes.", `

Support

WRNexusJS has no public Discord, public issue tracker, or guaranteed community support channel listed by this repository. Preview access and support begin through WorkRoot’s public contact path.

Include WRNexusJS version, Bun version, OS, a minimal reproduction, expected and actual behavior, and sanitized logs. Never include registry tokens, credentials, session cookies, or private data.

Support scope, service levels, and commercial terms require owner confirmation.

`, "Trust", ); page( "/license", "License", "Current WRNexusJS licensing status and private-preview terms boundary.", `

License

Owner decision required

This documentation repository contains no public license file, and the packages are unavailable from the public npm registry. No open-source license or redistribution right should be inferred.

Approved preview users must follow the private/commercial terms supplied by WorkRoot. Contact WorkRoot before copying, redistributing, or using WRNexusJS in production.

`, "Trust", ); page( "/search", "Search", "Search the local WRNexusJS documentation index without third-party tracking.", `

Search documentation

This build-time index is local and sends no query to a third party. Use your browser’s find command to filter this compact index.

Core documentation

${navigation.map(([href, label]) => `${label}`).join(" · ")}

Guides

${Object.entries( guides, ) .map(([slug, [title]]) => `${title}`) .join(" · ")}

Package APIs

${Object.keys(pkg.dependencies) .concat(Object.keys(pkg.devDependencies)) .filter((name) => name.startsWith("@wrnexus/")) .map((name) => `${name}`) .join(" · ")}

`, "Discovery", ); page( "/404", "Page not found", "Find the requested WRNexusJS documentation through search or the documentation index.", ``, "Error", ); const routes = [ "/", "/access", "/getting-started", "/tutorial", "/architecture", "/language", "/packages", ...Object.keys(guides).map((x) => `/guides/${x}`), "/examples", "/showcase", "/benchmarks", "/roadmap", "/changelog", `/releases/${version}`, "/security", "/support", "/license", "/search", "/404", ].filter(Boolean); const urls = [...new Set([...routes, ...packageNames.map((x) => `/packages/${x}`)])]; writeFileSync( join(pub, "robots.txt"), `User-agent: *\nAllow: /\nSitemap: https://wrnexusjs.dev/sitemap.xml\n`, ); writeFileSync( join(pub, "sitemap.xml"), `\n${urls.map((x) => `https://wrnexusjs.dev${x}`).join("")}\n`, ); await writeFormatted( join(pub, "docs-index.json"), JSON.stringify( { version, status: "private-developer-preview", generatedAt: "2026-07-13", documents: urls.map((url) => ({ url, title: url === "/" ? "WRNexusJS" : url.split("/").pop()!.replaceAll("-", " "), section: url.startsWith("/guides") ? "guide" : url.startsWith("/packages") ? "package" : "portal", version, stability: url.includes("mobile") || url.includes("queues") ? "experimental" : "preview", })), }, null, 2, ), ); writeFileSync( join(pub, "llms-full.txt"), `# WRNexusJS ${version} comprehensive documentation index\n\nStatus: Private Developer Preview. Runtime: Bun. UI language: .wrn.\nThis is the documentation application, not the framework monorepo.\n\n${urls.map((x) => `- https://wrnexusjs.dev${x}`).join("\n")}\n\nFor exact APIs, use installed package README files followed by exported declarations.\n\n# Complete @wrnexus/ui component reference\n\n${uiReferenceText}\n`, ); const packageMarker = "# Installed package documentation"; const existingGuide = readFileSync(join(pub, "llms.txt"), "utf8"); let frameworkGuide = existingGuide.split(`\n${packageMarker}`)[0]!.trim(); if (frameworkGuide.startsWith("# WRNexusJS documentation ")) { frameworkGuide = frameworkGuide.replace( /^# WRNexusJS documentation [^\n]+/, `# WRNexusJS documentation ${version}`, ); } else { frameworkGuide = `# WRNexusJS documentation ${version}\n\nStatus: Private Developer Preview. This site documents ${packageCount} release-aligned packages.\n\n${frameworkGuide}`; } const installedPackageDocs = packageNames .map((name) => { const packageRoot = join(root, "node_modules", "@wrnexus", name); const readme = readFileSync(join(packageRoot, "README.md"), "utf8").trim(); const declarations = readFileSync(join(packageRoot, "dist", "index.d.ts"), "utf8").trim(); return `## @wrnexus/${name}\n\nDocumentation URL: https://wrnexusjs.dev/packages/${name}\n\n${readme}\n\n### Exported TypeScript declarations\n\n\`\`\`ts\n${declarations}\n\`\`\``; }) .join("\n\n---\n\n"); writeFileSync( join(pub, "llms.txt"), `${frameworkGuide}\n\n# UI component catalog\n\nThe installed @wrnexus/ui release contains ${uiReference?.count ?? 0} documented components. Every mount name, prop type, required/default status, slot, and event is included below and in llms-full.txt.\n\n${uiReferenceText}\n\n${packageMarker}\n\nThe following README files and declarations come from the installed private ${version} release.\n\n${installedPackageDocs}\n`, ); const auditDocs: Record = { "site-audit.md": `# WRNexusJS site audit\n\nDate: 2026-07-13. Baseline: Bun 1.3.14, framework ${version}.\n\n## Baseline results\n\n- authenticated private-registry installation: pass.\n- docs generation: pass (${packageCount} package pages plus portal and guide pages).\n- tests, lint, formatting, and production build are required by the release check.\n- package access remains restricted/private.\n- repository: private WorkRoot Git remote; no public license file exists.\n\n## Findings\n\nPackage documentation, discovery assets, and AI-readable references are generated from the installed release. The ${version} portal includes the helpers package, workspace app addition, and safe forward-auth login redirect guidance.\n\n## Audit limitations\n\nBrowser tooling, Lighthouse, axe, screenshots, and authenticated production deployment checks are separate post-deploy work. Scores are not fabricated; reports belong under docs/audits/.\n`, "documentation-information-architecture.md": `# Documentation information architecture\n\nGlobal navigation groups Learn, Reference, Guides, Project, and Trust. Canonical discovery begins at the homepage, then /getting-started and /tutorial. Exact APIs live under /packages. Conceptual tasks live under /guides. Status and trust live at /roadmap, /changelog, /security, /support, /license, and /access. Machine discovery uses robots.txt, sitemap.xml, llms.txt, llms-full.txt, and docs-index.json.\n`, "release-access-status.md": `# Release and access status\n\n## Decision: Mode B — Private Developer Preview\n\nActive version: ${version}, derived from package.json#wrnexus.version. All ${packageCount} installed @wrnexus packages resolve to ${version} and npm reports restricted access. The repository remote is a private WorkRoot Git service and no public license file exists.\n\nExternal users cannot execute an installation without approved private registry credentials. The truthful CTA is Request preview access. After approval, the canonical command is bunx @wrnexus/cli@${version} create my-app. Tokens must never appear in documentation or source.\n`, "documentation-coverage-matrix.md": `# Documentation coverage matrix\n\n| Area | Package reference | Concept guide | Runnable fixture | Tests | Stability | Limitation |\n|---|---|---|---|---|---|---|\n${packageNames.map((x) => `| @wrnexus/${x} | /packages/${x} | ${["validation", "authz", "db", "uploader", "pubsub", "queue", "mobile"].includes(x) ? `/guides/${x === "authz" ? "authorization" : x === "validation" ? "forms-and-validation" : x === "uploader" ? "uploads" : x === "queue" ? "queues" : x}` : "Architecture/package guide"} | Planned | Generator coverage | ${["mobile", "native", "queue"].includes(x) ? "Experimental" : "Preview"} | No standalone CI fixture |`).join("\n")}\n`, "seo-metadata-matrix.md": `# SEO metadata matrix\n\nEvery canonical portal page defines a unique descriptive title, description, and absolute canonical. Package metadata is generated from installed package metadata. Sitemap and robots cover portal, guides, release, and package routes. Structured-data support is not exposed by the installed .wrn SEO grammar and remains a framework/generator gap. Preview routes remain indexable because the documentation is public; private package/source locations are not linked.\n`, "redirect-map.md": `# Redirect map\n\nNo legacy redirects are currently required: existing /, /getting-started, /architecture, /language, /packages, and /packages/:name remain canonical. If versioned archives are introduced, current unversioned docs should canonicalize to the active release and archived URLs must remain immutable.\n`, "release-checklist.md": `# Release checklist\n\n- [ ] Confirm all @wrnexus versions align with package.json#wrnexus.version.\n- [ ] Run bun install, docs:generate twice, test, check, build, and production smoke.\n- [ ] Verify clean-registry access status and CTA.\n- [ ] Crawl routes, links, anchors, canonical metadata, sitemap, robots, and AI files.\n- [ ] Run mobile/desktop accessibility and Lighthouse audits.\n- [ ] Confirm license, disclosure contact, support policy, changelog, and showcase approvals.\n- [ ] Verify no tokens, private paths, fake community links, or unsupported claims.\n`, "post-deploy-checklist.md": `# Post-deploy checklist\n\n1. Fetch representative HTML, robots.txt, sitemap.xml, llms.txt, llms-full.txt, and docs-index.json.\n2. Run Lighthouse mobile under controlled conditions; target performance/accessibility/SEO/best-practices >=95 with no critical accessibility issue.\n3. Run keyboard, screen reader, zoom, reduced-motion, link, anchor, and responsive overflow checks.\n4. Submit sitemap in Google Search Console and Bing Webmaster Tools after domain ownership is verified.\n5. Inspect canonical selection, rich-result eligibility, crawl errors, CSP reports, server logs, and 404s.\n6. Save dated reports under docs/audits/.\n`, }; for (const [name, body] of Object.entries(auditDocs)) { await writeFormatted(join(docs, name), body); } mkdirSync(join(docs, "audits"), { recursive: true }); writeFileSync( join(docs, "audits", "2026-07-12-baseline.md"), `# Baseline audit\n\nAutomated Bun install/docs/test/check/build passed before implementation. Lighthouse, browser accessibility, and screenshots were unavailable; no scores are claimed.\n`, ); console.log( `Generated portal pages, ${urls.length} discovery URLs, and audit deliverables for WRNexusJS ${version}.`, );