@nifrajs/web-vanilla 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nifra Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @nifrajs/web-vanilla
+
+Zero-framework render adapter for @nifrajs/web — auto-escaping tagged-template HTML, ~0 KB client JS, interactivity via @nifrajs/web/islands.
+
+Part of the **[nifra](https://nifra.dev)** full-stack TypeScript framework — one core, five UI libraries, every runtime. Scaffold a new app with `bun create nifra`.
+
+## Install
+
+```sh
+bun add @nifrajs/web-vanilla
+```
+
+## Docs
+
+- Reference: <https://nifra.dev/docs>
+- AI-readable: <https://nifra.dev/llms.txt>
+
+MIT

package/dist/compose.d.ts

@@ -0,0 +1,17 @@
+import type { RenderProps } from "@nifrajs/web";
+import type { Template } from "./html.js";
+/**
+ * A vanilla "component": a plain function from props to a {@link Template}. The page (innermost
+ * chain element) receives the loader {@link RenderProps}; a layout receives `{ children }` — the
+ * already-rendered inner fragment — plus the same render props, mirroring the React/Preact
+ * adapters' `children` contract.
+ */
+export type VanillaComponent = (props: RenderProps & {
+    children?: Template;
+}) => Template;
+/**
+ * Fold a layout chain (outermost layout → page) into one {@link Template}: render the page with
+ * the loader props, then wrap upward, each layout receiving the inner fragment as `children`.
+ */
+export declare function compose(chain: readonly unknown[], props: RenderProps): Template;
+//# sourceMappingURL=compose.d.ts.map

package/dist/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG;IAAE,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAE,KAAK,QAAQ,CAAA;AAEzF;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,QAAQ,CAO/E"}

package/dist/compose.js

@@ -0,0 +1,13 @@
+/**
+ * Fold a layout chain (outermost layout → page) into one {@link Template}: render the page with
+ * the loader props, then wrap upward, each layout receiving the inner fragment as `children`.
+ */
+export function compose(chain, props) {
+    const last = chain.length - 1;
+    let node = chain[last](props);
+    for (let i = last - 1; i >= 0; i--) {
+        node = chain[i]({ ...props, children: node });
+    }
+    return node;
+}
+//# sourceMappingURL=compose.js.map

package/dist/compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB;IACnE,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;IAC7B,IAAI,IAAI,GAAI,KAAK,CAAC,IAAI,CAAsB,CAAC,KAAK,CAAC,CAAA;IACnD,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,IAAI,GAAI,KAAK,CAAC,CAAC,CAAsB,CAAC,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAA;IACrE,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/html.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The tagged-template HTML engine — `html` builds an escaped-by-construction {@link Template}.
+ *
+ * Security model (the part that matters): every interpolated value is HTML-escaped by default.
+ * The ONLY ways to emit unescaped markup are (1) nesting another `html` template — already escaped
+ * by construction — and (2) an explicit {@link raw} wrapper, which is the audit-greppable opt-out.
+ * The escaper covers text and double-quoted attribute contexts (`& < > " '`); interpolations into
+ * unquoted attributes or inline scripts are NOT safe by design — the docs say "always quote".
+ */
+/** Branded wrapper marking a string as pre-trusted markup. Construct only via {@link raw}. */
+export declare class RawHtml {
+    readonly value: string;
+    constructor(value: string);
+}
+/**
+ * Mark a string as trusted, pre-escaped markup — it is emitted verbatim. The deliberate escape
+ * hatch (CMS-sanitized HTML, pre-rendered markdown): every call site is greppable, exactly like
+ * React's dangerouslySetInnerHTML, without the JSX.
+ */
+export declare function raw(trusted: string): RawHtml;
+/** A rendered HTML fragment — what `html` returns and components produce. Stringified once. */
+export declare class Template {
+    /** The final markup. Built eagerly at tag time (interpolations are already values by then). */
+    readonly html: string;
+    constructor(htmlString: string);
+    toString(): string;
+}
+/** What an interpolation may be: escaped primitives, nested templates/raw, arrays of the same.
+ * `null`/`undefined`/`false` render as nothing (conditional rendering: `cond && html\`…\``). */
+export type HtmlValue = string | number | bigint | boolean | null | undefined | Template | RawHtml | ReadonlyArray<HtmlValue>;
+/** The tag: `` html`<p>${user.name}</p>` `` → an escaped {@link Template}. */
+export declare function html(strings: TemplateStringsArray, ...values: HtmlValue[]): Template;
+//# sourceMappingURL=html.d.ts.map

package/dist/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../src/html.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,8FAA8F;AAC9F,qBAAa,OAAO;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;gBACV,KAAK,EAAE,MAAM;CAG1B;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5C;AAmCD,+FAA+F;AAC/F,qBAAa,QAAQ;IACnB,+FAA+F;IAC/F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;gBACT,UAAU,EAAE,MAAM;IAG9B,QAAQ,IAAI,MAAM;CAGnB;AAED;gGACgG;AAChG,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,QAAQ,GACR,OAAO,GACP,aAAa,CAAC,SAAS,CAAC,CAAA;AAoB5B,8EAA8E;AAC9E,wBAAgB,IAAI,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,SAAS,EAAE,GAAG,QAAQ,CAMpF"}

package/dist/html.js

@@ -0,0 +1,99 @@
+/**
+ * The tagged-template HTML engine — `html` builds an escaped-by-construction {@link Template}.
+ *
+ * Security model (the part that matters): every interpolated value is HTML-escaped by default.
+ * The ONLY ways to emit unescaped markup are (1) nesting another `html` template — already escaped
+ * by construction — and (2) an explicit {@link raw} wrapper, which is the audit-greppable opt-out.
+ * The escaper covers text and double-quoted attribute contexts (`& < > " '`); interpolations into
+ * unquoted attributes or inline scripts are NOT safe by design — the docs say "always quote".
+ */
+/** Branded wrapper marking a string as pre-trusted markup. Construct only via {@link raw}. */
+export class RawHtml {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+/**
+ * Mark a string as trusted, pre-escaped markup — it is emitted verbatim. The deliberate escape
+ * hatch (CMS-sanitized HTML, pre-rendered markdown): every call site is greppable, exactly like
+ * React's dangerouslySetInnerHTML, without the JSX.
+ */
+export function raw(trusted) {
+    return new RawHtml(trusted);
+}
+const ESCAPE_RE = /[&<>"']/;
+const escapeHtml = (s) => {
+    // Fast path: most text has nothing to escape — one regex probe, zero allocation.
+    if (!ESCAPE_RE.test(s))
+        return s;
+    let out = "";
+    let last = 0;
+    for (let i = 0; i < s.length; i++) {
+        let entity;
+        switch (s.charCodeAt(i)) {
+            case 38:
+                entity = "&amp;";
+                break;
+            case 60:
+                entity = "&lt;";
+                break;
+            case 62:
+                entity = "&gt;";
+                break;
+            case 34:
+                entity = "&quot;";
+                break;
+            case 39:
+                entity = "&#39;";
+                break;
+            default:
+                continue;
+        }
+        out += s.slice(last, i) + entity;
+        last = i + 1;
+    }
+    return out + s.slice(last);
+};
+/** A rendered HTML fragment — what `html` returns and components produce. Stringified once. */
+export class Template {
+    /** The final markup. Built eagerly at tag time (interpolations are already values by then). */
+    html;
+    constructor(htmlString) {
+        this.html = htmlString;
+    }
+    toString() {
+        return this.html;
+    }
+}
+function renderValue(value) {
+    if (value == null || value === false)
+        return "";
+    if (typeof value === "string")
+        return escapeHtml(value);
+    if (typeof value === "number" || typeof value === "bigint")
+        return String(value);
+    if (value === true)
+        return "true";
+    if (value instanceof Template)
+        return value.html;
+    if (value instanceof RawHtml)
+        return value.value;
+    if (Array.isArray(value)) {
+        let out = "";
+        for (const item of value)
+            out += renderValue(item);
+        return out;
+    }
+    // Objects/functions are a bug at the call site — render loudly rather than "[object Object]".
+    throw new TypeError(`[nifra/web-vanilla] html: unsupported interpolation of type ${typeof value} — interpolate strings, numbers, nested html\`…\`, raw(), or arrays of those`);
+}
+/** The tag: `` html`<p>${user.name}</p>` `` → an escaped {@link Template}. */
+export function html(strings, ...values) {
+    let out = strings[0];
+    for (let i = 0; i < values.length; i++) {
+        out += renderValue(values[i]) + strings[i + 1];
+    }
+    return new Template(out);
+}
+//# sourceMappingURL=html.js.map

package/dist/html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.js","sourceRoot":"","sources":["../src/html.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @nifrajs/web-vanilla — the zero-framework render adapter for @nifrajs/web.
+ *
+ * Pages are plain functions returning auto-escaping `html` tagged templates; the client ships
+ * **no framework runtime at all**. Use it for content/SEO surfaces (landing pages, listings,
+ * docs, comparison tables) where HTML is the product — interactivity comes from
+ * `@nifrajs/web/islands` entries (`islandScripts`), each a hand-sized vanilla module.
+ *
+ * Routes using this adapter are server-rendered documents, not hydrated apps — set
+ * `export const hydrate = false` on the route (there is no client runtime to hydrate with);
+ * `renderPage` then omits the framework bootstrap entirely. Loaders, actions, ISR, SSG, head
+ * management, and streaming all work unchanged — they live in @nifrajs/web, not the view layer.
+ *
+ *   import { html, vanillaAdapter } from "@nifrajs/web-vanilla"
+ *
+ *   export default function Hotels({ data }) {
+ *     const { hotels } = data as { hotels: Array<{ name: string; pricePaise: number }> }
+ *     return html`<ul>${hotels.map((h) => html`<li>${h.name} — ₹${h.pricePaise / 100}</li>`)}</ul>`
+ *   }
+ */
+import type { RenderAdapter } from "@nifrajs/web";
+export { compose, type VanillaComponent } from "./compose.js";
+export { type HtmlValue, html, RawHtml, raw, Template } from "./html.js";
+/** The zero-framework server render adapter — pass to @nifrajs/web's `renderPage`/`createWebApp`. */
+export declare const vanillaAdapter: RenderAdapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,cAAc,CAAA;AAG9D,OAAO,EAAE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC7D,OAAO,EAAE,KAAK,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAIxE,qGAAqG;AACrG,eAAO,MAAM,cAAc,EAAE,aAsB5B,CAAA"}

package/dist/index.js

@@ -0,0 +1,49 @@
+/**
+ * @nifrajs/web-vanilla — the zero-framework render adapter for @nifrajs/web.
+ *
+ * Pages are plain functions returning auto-escaping `html` tagged templates; the client ships
+ * **no framework runtime at all**. Use it for content/SEO surfaces (landing pages, listings,
+ * docs, comparison tables) where HTML is the product — interactivity comes from
+ * `@nifrajs/web/islands` entries (`islandScripts`), each a hand-sized vanilla module.
+ *
+ * Routes using this adapter are server-rendered documents, not hydrated apps — set
+ * `export const hydrate = false` on the route (there is no client runtime to hydrate with);
+ * `renderPage` then omits the framework bootstrap entirely. Loaders, actions, ISR, SSG, head
+ * management, and streaming all work unchanged — they live in @nifrajs/web, not the view layer.
+ *
+ *   import { html, vanillaAdapter } from "@nifrajs/web-vanilla"
+ *
+ *   export default function Hotels({ data }) {
+ *     const { hotels } = data as { hotels: Array<{ name: string; pricePaise: number }> }
+ *     return html`<ul>${hotels.map((h) => html`<li>${h.name} — ₹${h.pricePaise / 100}</li>`)}</ul>`
+ *   }
+ */
+import { compose } from "./compose.js";
+export { compose } from "./compose.js";
+export { html, RawHtml, raw, Template } from "./html.js";
+const ENCODER = new TextEncoder();
+/** The zero-framework server render adapter — pass to @nifrajs/web's `renderPage`/`createWebApp`. */
+export const vanillaAdapter = {
+    // One-pass string render — renderPage's buffered fast path uses this for every non-deferred
+    // page, which for vanilla routes is the norm.
+    renderToString(chain, props) {
+        return compose(chain, props).html;
+    },
+    // Deferred pages need the streaming seam; a synchronous renderer satisfies it with a one-chunk
+    // stream (the shell IS the document — vanilla has no Suspense boundaries of its own; @nifrajs/web's
+    // defer()/<no-js fallback> machinery handles progressive data above this seam).
+    renderToStream(chain, props) {
+        const body = compose(chain, props).html;
+        return new ReadableStream({
+            start(controller) {
+                controller.enqueue(ENCODER.encode(body));
+                controller.close();
+            },
+        });
+    },
+    // No client runtime ⇒ no per-document bootstrap markup.
+    hydrationHead() {
+        return "";
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,OAAO,EAAE,OAAO,EAAyB,MAAM,cAAc,CAAA;AAC7D,OAAO,EAAkB,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAExE,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAA;AAEjC,qGAAqG;AACrG,MAAM,CAAC,MAAM,cAAc,GAAkB;IAC3C,4FAA4F;IAC5F,8CAA8C;IAC9C,cAAc,CAAC,KAAyB,EAAE,KAAkB;QAC1D,OAAO,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,CAAA;IACnC,CAAC;IACD,+FAA+F;IAC/F,oGAAoG;IACpG,gFAAgF;IAChF,cAAc,CAAC,KAAyB,EAAE,KAAkB;QAC1D,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,CAAA;QACvC,OAAO,IAAI,cAAc,CAAa;YACpC,KAAK,CAAC,UAAU;gBACd,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA;gBACxC,UAAU,CAAC,KAAK,EAAE,CAAA;YACpB,CAAC;SACF,CAAC,CAAA;IACJ,CAAC;IACD,wDAAwD;IACxD,aAAa;QACX,OAAO,EAAE,CAAA;IACX,CAAC;CACF,CAAA"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@nifrajs/web-vanilla",
+  "version": "0.1.0-alpha.1",
+  "description": "Zero-framework render adapter for @nifrajs/web — auto-escaping tagged-template HTML, ~0 KB client JS, interactivity via @nifrajs/web/islands.",
+  "keywords": [
+    "bun",
+    "typescript",
+    "nifra",
+    "web-framework",
+    "full-stack",
+    "edge",
+    "ssr"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && bun run ../../scripts/fix-dts.ts dist",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@nifrajs/web": "workspace:*"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nifrajs/nifra.git",
+    "directory": "packages/web-vanilla"
+  },
+  "bugs": {
+    "url": "https://github.com/nifrajs/nifra/issues"
+  },
+  "homepage": "https://github.com/nifrajs/nifra#readme"
+}

package/src/compose.ts

@@ -0,0 +1,23 @@
+import type { RenderProps } from "@nifrajs/web"
+import type { Template } from "./html.ts"
+
+/**
+ * A vanilla "component": a plain function from props to a {@link Template}. The page (innermost
+ * chain element) receives the loader {@link RenderProps}; a layout receives `{ children }` — the
+ * already-rendered inner fragment — plus the same render props, mirroring the React/Preact
+ * adapters' `children` contract.
+ */
+export type VanillaComponent = (props: RenderProps & { children?: Template }) => Template
+
+/**
+ * Fold a layout chain (outermost layout → page) into one {@link Template}: render the page with
+ * the loader props, then wrap upward, each layout receiving the inner fragment as `children`.
+ */
+export function compose(chain: readonly unknown[], props: RenderProps): Template {
+  const last = chain.length - 1
+  let node = (chain[last] as VanillaComponent)(props)
+  for (let i = last - 1; i >= 0; i--) {
+    node = (chain[i] as VanillaComponent)({ ...props, children: node })
+  }
+  return node
+}

package/src/html.ts

@@ -0,0 +1,111 @@
+/**
+ * The tagged-template HTML engine — `html` builds an escaped-by-construction {@link Template}.
+ *
+ * Security model (the part that matters): every interpolated value is HTML-escaped by default.
+ * The ONLY ways to emit unescaped markup are (1) nesting another `html` template — already escaped
+ * by construction — and (2) an explicit {@link raw} wrapper, which is the audit-greppable opt-out.
+ * The escaper covers text and double-quoted attribute contexts (`& < > " '`); interpolations into
+ * unquoted attributes or inline scripts are NOT safe by design — the docs say "always quote".
+ */
+
+/** Branded wrapper marking a string as pre-trusted markup. Construct only via {@link raw}. */
+export class RawHtml {
+  readonly value: string
+  constructor(value: string) {
+    this.value = value
+  }
+}
+
+/**
+ * Mark a string as trusted, pre-escaped markup — it is emitted verbatim. The deliberate escape
+ * hatch (CMS-sanitized HTML, pre-rendered markdown): every call site is greppable, exactly like
+ * React's dangerouslySetInnerHTML, without the JSX.
+ */
+export function raw(trusted: string): RawHtml {
+  return new RawHtml(trusted)
+}
+
+const ESCAPE_RE = /[&<>"']/
+const escapeHtml = (s: string): string => {
+  // Fast path: most text has nothing to escape — one regex probe, zero allocation.
+  if (!ESCAPE_RE.test(s)) return s
+  let out = ""
+  let last = 0
+  for (let i = 0; i < s.length; i++) {
+    let entity: string
+    switch (s.charCodeAt(i)) {
+      case 38:
+        entity = "&amp;"
+        break
+      case 60:
+        entity = "&lt;"
+        break
+      case 62:
+        entity = "&gt;"
+        break
+      case 34:
+        entity = "&quot;"
+        break
+      case 39:
+        entity = "&#39;"
+        break
+      default:
+        continue
+    }
+    out += s.slice(last, i) + entity
+    last = i + 1
+  }
+  return out + s.slice(last)
+}
+
+/** A rendered HTML fragment — what `html` returns and components produce. Stringified once. */
+export class Template {
+  /** The final markup. Built eagerly at tag time (interpolations are already values by then). */
+  readonly html: string
+  constructor(htmlString: string) {
+    this.html = htmlString
+  }
+  toString(): string {
+    return this.html
+  }
+}
+
+/** What an interpolation may be: escaped primitives, nested templates/raw, arrays of the same.
+ * `null`/`undefined`/`false` render as nothing (conditional rendering: `cond && html\`…\``). */
+export type HtmlValue =
+  | string
+  | number
+  | bigint
+  | boolean
+  | null
+  | undefined
+  | Template
+  | RawHtml
+  | ReadonlyArray<HtmlValue>
+
+function renderValue(value: HtmlValue): string {
+  if (value == null || value === false) return ""
+  if (typeof value === "string") return escapeHtml(value)
+  if (typeof value === "number" || typeof value === "bigint") return String(value)
+  if (value === true) return "true"
+  if (value instanceof Template) return value.html
+  if (value instanceof RawHtml) return value.value
+  if (Array.isArray(value)) {
+    let out = ""
+    for (const item of value) out += renderValue(item)
+    return out
+  }
+  // Objects/functions are a bug at the call site — render loudly rather than "[object Object]".
+  throw new TypeError(
+    `[nifra/web-vanilla] html: unsupported interpolation of type ${typeof value} — interpolate strings, numbers, nested html\`…\`, raw(), or arrays of those`,
+  )
+}
+
+/** The tag: `` html`<p>${user.name}</p>` `` → an escaped {@link Template}. */
+export function html(strings: TemplateStringsArray, ...values: HtmlValue[]): Template {
+  let out = strings[0] as string
+  for (let i = 0; i < values.length; i++) {
+    out += renderValue(values[i] as HtmlValue) + (strings[i + 1] as string)
+  }
+  return new Template(out)
+}

package/src/index.ts

@@ -0,0 +1,53 @@
+/**
+ * @nifrajs/web-vanilla — the zero-framework render adapter for @nifrajs/web.
+ *
+ * Pages are plain functions returning auto-escaping `html` tagged templates; the client ships
+ * **no framework runtime at all**. Use it for content/SEO surfaces (landing pages, listings,
+ * docs, comparison tables) where HTML is the product — interactivity comes from
+ * `@nifrajs/web/islands` entries (`islandScripts`), each a hand-sized vanilla module.
+ *
+ * Routes using this adapter are server-rendered documents, not hydrated apps — set
+ * `export const hydrate = false` on the route (there is no client runtime to hydrate with);
+ * `renderPage` then omits the framework bootstrap entirely. Loaders, actions, ISR, SSG, head
+ * management, and streaming all work unchanged — they live in @nifrajs/web, not the view layer.
+ *
+ *   import { html, vanillaAdapter } from "@nifrajs/web-vanilla"
+ *
+ *   export default function Hotels({ data }) {
+ *     const { hotels } = data as { hotels: Array<{ name: string; pricePaise: number }> }
+ *     return html`<ul>${hotels.map((h) => html`<li>${h.name} — ₹${h.pricePaise / 100}</li>`)}</ul>`
+ *   }
+ */
+
+import type { RenderAdapter, RenderProps } from "@nifrajs/web"
+import { compose } from "./compose.ts"
+
+export { compose, type VanillaComponent } from "./compose.ts"
+export { type HtmlValue, html, RawHtml, raw, Template } from "./html.ts"
+
+const ENCODER = new TextEncoder()
+
+/** The zero-framework server render adapter — pass to @nifrajs/web's `renderPage`/`createWebApp`. */
+export const vanillaAdapter: RenderAdapter = {
+  // One-pass string render — renderPage's buffered fast path uses this for every non-deferred
+  // page, which for vanilla routes is the norm.
+  renderToString(chain: readonly unknown[], props: RenderProps): string {
+    return compose(chain, props).html
+  },
+  // Deferred pages need the streaming seam; a synchronous renderer satisfies it with a one-chunk
+  // stream (the shell IS the document — vanilla has no Suspense boundaries of its own; @nifrajs/web's
+  // defer()/<no-js fallback> machinery handles progressive data above this seam).
+  renderToStream(chain: readonly unknown[], props: RenderProps): ReadableStream<Uint8Array> {
+    const body = compose(chain, props).html
+    return new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(ENCODER.encode(body))
+        controller.close()
+      },
+    })
+  },
+  // No client runtime ⇒ no per-document bootstrap markup.
+  hydrationHead(): string {
+    return ""
+  },
+}