Book Serif Index

Meng ToCommunityCreated by Meng To

Skill
Content generator
Design and creative
MIT
Medium risk

From the author

Create an archival book-reader design system with serif-led pages, mono index navigation, aged paper surfaces, margin notes, and a premium catalog frame.

— the description by Meng To

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The Book Serif Index skill provides a structured design framework for building immersive, editorial-focused interfaces. It emphasizes a two-zone composition that pairs a tactile, book-like reading surface with a technical, mono-styled catalog frame. By combining serif typography, aged paper textures, and scholarly layout elements like marginalia and folio markers, the system creates a sophisticated environment suitable for archives, lore systems, and literary catalogs.

What it does

Defines a two-zone layout with a dark outer shell and a light, textured book-like interior.
Provides typographic guidelines pairing serif body text with mono-spaced utility labels.
Details material design elements like center creases, edge shadows, and paper gradients.
Suggests scholarly UI components such as annotation cards, drop caps, and index-style sidebars.
Offers tuning parameters to balance historical antiquity with modern technical clarity.
Establishes a restrained, atmospheric color palette with selective accent usage.

When to use it

When designing interfaces for digital archives, manuscript viewers, or research platforms.
When building story-driven product pages that require a literary or curated feel.
When creating reading-centric layouts that need to balance immersive content with technical navigation.
When you need a design system that feels like a premium, collected catalog.

Advantages

Creates a highly immersive and tactile user experience.
Provides a clear, disciplined structure for editorial content.
Balances aesthetic warmth with functional, index-based navigation.
Highly customizable through tuning knobs for antiquity and technical density.

Usage examples

“Design a landing page for a historical archive using the Book Serif Index system.”: The agent generates a layout featuring a central, textured paper-like reading area surrounded by a dark, mono-indexed sidebar, using serif typography for the historical content.
“Apply the Book Serif Index style to a lore-heavy game wiki.”: The agent produces a design with dual-panel page spreads, marginalia for lore annotations, and a technical catalog frame for navigation.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/mengto/book-serif-index/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip book-serif-index.zip -d .agents/skills

Documentation by Meng To

Book Serif Index Skill

Use When

Create an archival book-reader design system with serif-led pages, mono index navigation, aged paper surfaces, margin notes, and a premium catalog frame.

Workflow

Scope

Apply this as a full design-system direction when the interface should feel like a curated archival reader, manuscript viewer, or premium literary catalog.
Use it for editorial experiences, story-driven product pages, archives, research interfaces, lore systems, or reading-centric layouts that need bookish structure and index navigation.
This is not generic blog styling; it should combine immersive book surfaces with a technical or catalog-like outer frame.

Visual target

Create a central reading surface that feels like an open book, folio spread, or archival document laid within a darker surrounding interface shell.
Let typography lead the experience: display serif or gothic-inspired headings, readable serif body text, and mono utility labels for navigation, metadata, and indexing.
Use aged paper tones, subtle texture, crease shadows, edge shading, and light wear so the main content surface feels tactile and collected.
Surround the reading area with restrained index or catalog UI: sidebar sections, chapter markers, section lists, archive labels, or mono navigation rails.
Keep the palette restrained and atmospheric: dark outer shell, warm paper interior, muted ink tones, and one selective accent color derived from the design. If no brand accent exists, a subdued oxblood, bronze, or antique gold is acceptable.

Implementation guidance

Prefer a two-zone composition: a darker outer interface frame plus a lighter book-like content surface centered inside it.
Use serif body copy with generous line height for readability, then pair it with mono labels, tracking-heavy section names, and quiet metadata for contrast.
Build the book surface with gradients, inset shadows, subtle center crease treatment, edge shadows, and light paper texture so it reads as layered material rather than a flat beige card.
Include index-like navigation patterns such as chapter lists, section trees, archive groupings, or sidebar entries with active states and small markers.
Add scholarly details like drop caps, marginalia boxes, block labels, annotations, citations, folio markers, or footer metadata to reinforce the editorial system.
Motion should stay calm and literary: masked text reveals, gentle entrance motion, slow ambient background drift, and restrained hover cues.

Recommended patterns

Outer shell: dark full-screen container with thin frame lines, subtle vertical rails, and muted corner markers.
Book spread: two-page or dual-panel reading region with center crease, paper gradients, soft edge shadows, and slight tonal variation between pages.
Index navigation: mono sidebar with grouped headings, active bullets, archive sections, or chapter entries arranged like a catalog.
Reading details: drop caps, pull quotes, annotation cards, marginal notes, image plates with thin framed borders, and bottom folio labels.
Typography system: decorative serif display, highly readable serif body, and mono metadata used sparingly for structure.

Tuning knobs

Antiquity: increase or reduce the amount of paper texture, warm tint, and wear depending on how historical versus contemporary the interface should feel.
Technical overlay: add or remove catalog rails, index labels, and metadata so the design can lean more archival or more system-like.
Book realism: tune crease depth, page shadows, and paper contrast so the surface feels tactile without becoming skeuomorphic overload.
Accent use: keep accent color concentrated in headings, active index states, callouts, or notes instead of spreading it across the whole spread.
Density: choose between airy museum-like composition or denser scholarly indexing depending on the content.

Avoid

Flat cream cards with serif text but no convincing book or archive structure.
Generic publishing layouts that omit index rails, metadata, and material depth.
Bright modern SaaS color systems that break the archival tone.
Excessive distressed effects that make the interface dirty or hard to read.
Overly ornate fantasy styling without the disciplined catalog and editorial framework.

Files

ATTRIBUTION.mdAdded by AutoGineer854 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md4.4 KiB
demo/PROMPT.md3.4 KiB
demo/assets/page-01-e534354d-c5f2-4399-a1d9-2f50338e8c47-1600w.jpg83.3 KiB
demo/assets/page-02-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg966.2 KiB
demo/assets/source-preview.jpg76.2 KiB
demo/index.html58.6 KiB
demo/preview.jpg60.3 KiB
demo/source.json3.6 KiB

demo/index.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta name="neuform-sandboxed-demo" content="1">
  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; connect-src 'self'; frame-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'; object-src 'none'">
  <title>Sandboxed Neuform demo</title>
  <style>
    html, body, iframe { width: 100%; height: 100%; margin: 0; border: 0; }
    body { overflow: hidden; background: #0b0b0b; }
    iframe { display: block; background: white; }
    .error { box-sizing: border-box; min-height: 100%; padding: 32px; color: #fff; font: 16px/1.5 system-ui, sans-serif; }
  </style>
</head>
<body>
  <iframe id="neuform-demo" title="Sandboxed Neuform design demo" sandbox="allow-scripts" referrerpolicy="no-referrer"></iframe>
  <script>
    const encodedHtml = "<!DOCTYPE html>
<html lang="en" class="scroll-smooth">
<head>
<meta http-equiv="Content-Security-Policy" content="default-src 'none'; base-uri 'none'; connect-src 'none'; font-src data: https://fonts.gstatic.com; form-action 'none'; frame-src 'none'; img-src blob:; media-src blob:; navigate-to 'none'; object-src 'none'; script-src 'unsafe-inline' __NEUFORM_RUNTIME_SOURCES__; style-src 'unsafe-inline' https://api.fontshare.com https://fonts.googleapis.com; worker-src 'none'">
<script data-neuform-asset-bootstrap>
(() => {
  let received = false;
  const objectUrls = [];
  const replaceAll = (value, replacements) => {
    let next = String(value || "");
    for (const [file, objectUrl] of replacements) next = next.split(file).join(objectUrl);
    return next;
  };
  window.addEventListener("message", (event) => {
    if (received || event.source !== parent || event.data?.type !== "neuform-assets-v1") return;
    received = true;
    const replacements = [];
    for (const asset of event.data.assets || []) {
      if (!asset || typeof asset.file !== "string" || typeof asset.base64 !== "string") continue;
      const binary = atob(asset.base64);
      const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
      const objectUrl = URL.createObjectURL(new Blob([bytes], { type: asset.contentType || "application/octet-stream" }));
      objectUrls.push(objectUrl);
      replacements.push([asset.file, objectUrl]);
    }
    for (const element of document.querySelectorAll("*")) {
      for (const name of ["src", "poster", "srcset", "style"]) {
        const value = element.getAttribute(name);
        if (value) element.setAttribute(name, replaceAll(value, replacements));
      }
    }
    for (const style of document.querySelectorAll("style")) {
      style.textContent = replaceAll(style.textContent, replacements);
    }
  });
  window.addEventListener("pagehide", () => {
    for (const objectUrl of objectUrls) URL.revokeObjectURL(objectUrl);
  }, { once: true });
})();
</script>

<meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Omni — Corporate Neural Memory</title>
    
    <!-- Tailwind CSS -->
    <script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
    
    <!-- Google Fonts -->
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500&family=JetBrains+Mono:wght@400&display=swap" rel="stylesheet">
    
    <!-- Iconify -->
    <script src="../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js"></script>
    
    <!-- GSAP & Three.js -->
    <script src="../../../../assets/runtime/runtime-027051effa47-gsap-min.js"></script>
    <script src="../../../../assets/runtime/runtime-689ca8dda44c-scrolltrigger-min.js"></script>
    <script src="../../../../assets/runtime/runtime-25023b521d77-three-min.js"></script>

    <script>
        tailwind.config = {
            theme: {
                extend: {
                    fontFamily: {
                        sans: ['Inter', 'sans-serif'],
                        mono: ['JetBrains Mono', 'monospace'],
                    },
                    colors: {
                        navy: {
                            900: '#020617',
                            950: '#01030a',
                        },
                        emerald: {
                            400: '#34d399',
                            500: '#10b981',
                        }
                    },
                    fontSize: {
                        '2xs': '0.65rem',
                    }
                }
            }
        }
    </script>

    <style>
        /* Typography adjustments */
        body { font-family: 'Inter', sans-serif; background-color: #020617; color: #ffffff; overflow-x: hidden; }
        .font-mono { font-family: 'JetBrains Mono', monospace; }
        
        /* Progressive Blur Navigation */
        .nav-blur { position: fixed; z-index: 50; inset: 0 0 auto 0; height: 12%; pointer-events: none; }
        .nav-blur > div, .nav-blur::before, .nav-blur::after { position: absolute; inset: 0; }
        .nav-blur::before { content: ""; z-index: 1; backdrop-filter: blur(0.5px); mask-image: linear-gradient(to top, rgba(0,0,0,0) 0%, rgba(0,0,0,1) 12.5%, rgba(0,0,0,1) 25%, rgba(0,0,0,0) 37.5%); -webkit-mask-image: linear-gradient(to top, rgba(0,0,0,0) 0%, rgba(0,0,0,1) 12.5%, rgba(0,0,0,1) 25%, rgba(0,0,0,0) 37.5%); }
        .nav-blur > div:nth-of-type(1) { z-index: 2; backdrop-filter: blur(1px); mask-image: linear-gradient(to top, rgba(0,0,0,0) 12.5%, rgba(0,0,0,1) 25%, rgba(0,0,0,1) 37.5%, rgba(0,0,0,0) 50%); -webkit-mask-image: linear-gradient(to top, rgba(0,0,0,0) 12.5%, rgba(0,0,0,1) 25%, rgba(0,0,0,1) 37.5%, rgba(0,0,0,0) 50%); }
        .nav-blur > div:nth-of-type(2) { z-index: 3; backdrop-filter: blur(2px); mask-image: linear-gradient(to top, rgba(0,0,0,0) 25%, rgba(0,0,0,1) 37.5%, rgba(0,0,0,1) 50%, rgba(0,0,0,0) 62.5%); -webkit-mask-image: linear-gradient(to top, rgba(0,0,0,0) 25%, rgba(0,0,0,1) 37.5%, rgba(0,0,0,1) 50%, rgba(0,0,0,0) 62.5%); }
        .nav-blur > div:nth-of-type(3) { z-index: 4; backdrop-filter: blur(4px); mask-image: linear-gradient(to top, rgba(0,0,0,0) 37.5%, rgba(0,0,0,1) 50%, rgba(0,0,0,1) 62.5%, rgba(0,0,0,0) 75%); -webkit-mask-image: linear-gradient(to top, rgba(0,0,0,0) 37.5%, rgba(0,0,0,1) 50%, rgba(0,0,0,1) 62.5%, rgba(0,0,0,0) 75%); }
        .nav-blur > div:nth-of-type(4) { z-index: 5; backdrop-filter: blur(8px); mask-image: linear-gradient(to top, rgba(0,0,0,0) 50%, rgba(0,0,0,1) 62.5%, rgba(0,0,0,1) 75%, rgba(0,0,0,0) 87.5%); -webkit-mask-image: linear-gradient(to top, rgba(0,0,0,0) 50%, rgba(0,0,0,1) 62.5%, rgba(0,0,0,1) 75%, rgba(0,0,0,0) 87.5%); }
        .nav-blur > div:nth-of-type(5) { z-index: 6; backdrop-filter: blur(16px); mask-image: linear-gradient(to top, rgba(0,0,0,0) 62.5%, rgba(0,0,0,1) 75%, rgba(0,0,0,1) 87.5%, rgba(0,0,0,0) 100%); -webkit-mask-image: linear-gradient(to top, rgba(0,0,0,0) 62.5%, rgba(0,0,0,1) 75%, rgba(0,0,0,1) 87.5%, rgba(0,0,0,0) 100%); }
        .nav-blur > div:nth-of-type(6) { z-index: 7; backdrop-filter: blur(32px); mask-image: linear-gradient(to top, rgba(0,0,0,0) 75%, rgba(0,0,0,1) 87.5%, rgba(0,0,0,1) 100%); -webkit-mask-image: linear-gradient(to top, rgba(0,0,0,0) 75%, rgba(0,0,0,1) 87.5%, rgba(0,0,0,1) 100%); }
        .nav-blur::after { content: ""; z-index: 8; backdrop-filter: blur(64px); mask-image: linear-gradient(to top, rgba(0,0,0,0) 87.5%, rgba(0,0,0,1) 100%); -webkit-mask-image: linear-gradient(to top, rgba(0,0,0,0) 87.5%, rgba(0,0,0,1) 100%); }

        /* Diagonal Corners */
        .clip-diagonal { clip-path: polygon(12px 0, 100% 0, 100% calc(100% - 12px), calc(100% - 12px) 100%, 0 100%, 0 12px); }
        .clip-diagonal-card { clip-path: polygon(24px 0, 100% 0, 100% calc(100% - 24px), calc(100% - 24px) 100%, 0 100%, 0 24px); }

        /* Dither & Grain Overlays */
        .bg-dither { background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 4 4' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M1 0H0v1h1zM3 2H2v1h1zM0 2h1v1H0zM2 0h1v1H2z' fill='%23ffffff' fill-opacity='0.03'/%3E%3C/svg%3E"); }
        .bg-noise { background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 200 200' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='noiseFilter'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.85' numOctaves='3' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23noiseFilter)'/%3E%3C/svg%3E"); }
        
        /* Grid Background */
        .bg-tech-grid { background-image: linear-gradient(rgba(255,255,255,0.02) 1px, transparent 1px), linear-gradient(90deg, rgba(255,255,255,0.02) 1px, transparent 1px); background-size: 40px 40px; }

        /* Masked Reveal Utility */
        .reveal-mask { display: inline-block; overflow: hidden; vertical-align: bottom; }
        .reveal-text { display: inline-block; transform: translateY(110%); }

        /* Skeuomorphic Glass */
        .glass-panel { background: rgba(10, 12, 20, 0.6); backdrop-filter: blur(16px); -webkit-backdrop-filter: blur(16px); box-shadow: inset 0 1px 1px rgba(255,255,255,0.1), inset 0 -1px 1px rgba(0,0,0,0.8), 0 24px 24px -12px rgba(0,0,0,0.4); }
        
        /* Custom Scrollbar */
        ::-webkit-scrollbar { width: 6px; }
        ::-webkit-scrollbar-track { background: #020617; }
        ::-webkit-scrollbar-thumb { background: #1e293b; border-radius: 10px; }
    </style>
</head>
<body class="selection:bg-emerald-500/30 selection:text-white">

    <!-- WebGL Background Layer -->
    <canvas id="webgl-canvas" class="fixed inset-0 z-0 pointer-events-none opacity-60"></canvas>

    <!-- Global Overlays -->
    <div class="fixed inset-0 z-0 pointer-events-none bg-dither"></div>
    <div class="fixed inset-0 z-0 pointer-events-none bg-noise opacity-[0.04] mix-blend-overlay"></div>
    <div class="fixed inset-0 z-0 pointer-events-none bg-tech-grid opacity-50"></div>

    <!-- Progressive Blur Header -->
    <div class="nav-blur">
        <div></div><div></div><div></div><div></div><div></div><div></div>
    </div>

    <!-- Navigation -->
    <nav class="fixed top-0 w-full z-50 flex justify-center pt-6 px-4 pointer-events-none">
        <div class="pointer-events-auto flex items-center justify-between w-full max-w-5xl bg-navy-900/40 backdrop-blur-md border border-white/10 p-[1px] clip-diagonal relative group">
            <div class="absolute inset-0 bg-gradient-to-r from-emerald-500/10 to-transparent opacity-0 group-hover:opacity-100 transition-opacity duration-500 clip-diagonal"></div>
            <div class="w-full bg-navy-950/80 clip-diagonal flex items-center justify-between px-6 py-3">
                <div class="flex items-center gap-3">
                    <div class="w-2 h-2 bg-emerald-400 border border-emerald-200/50"></div>
                    <span class="text-sm font-medium tracking-wide">OMNI_SYS</span>
                </div>
                <div class="hidden md:flex items-center gap-8 text-xs font-mono tracking-widest text-neutral-400">
                    <a href="#" class="hover:text-white transition-colors uppercase">Architecture</a>
                    <a href="#" class="hover:text-white transition-colors uppercase">Intelligence</a>
                    <a href="#" class="hover:text-white transition-colors uppercase">Security</a>
                </div>
                <button class="text-xs font-mono tracking-widest bg-white text-black px-4 py-2 clip-diagonal hover:bg-neutral-200 transition-colors uppercase flex items-center gap-2">
                    Initialize <iconify-icon icon="solar:arrow-right-linear" stroke-width="1.5"></iconify-icon>
                </button>
            </div>
        </div>
    </nav>

    <!-- Main Container Shell (Agency Minimal Grid) -->
    <main class="relative z-10 w-full max-w-7xl mx-auto border-x border-white/10 min-h-screen pt-32 flex flex-col">
        <!-- Global Vertical Rails -->
        <div class="absolute top-0 bottom-0 left-1/4 w-[1px] bg-white/5 pointer-events-none hidden lg:block"></div>
        <div class="absolute top-0 bottom-0 left-2/4 w-[1px] bg-white/5 pointer-events-none hidden lg:block"></div>
        <div class="absolute top-0 bottom-0 left-3/4 w-[1px] bg-white/5 pointer-events-none hidden lg:block"></div>

        <!-- HERO SECTION -->
        <section class="relative px-6 lg:px-16 pt-20 pb-32 border-b border-white/10">
            <!-- Corner Brackets -->
            <div class="absolute top-0 left-0 w-4 h-4 border-t border-l border-white/30 -translate-x-[1px] -translate-y-[1px]"></div>
            <div class="absolute top-0 right-0 w-4 h-4 border-t border-r border-white/30 translate-x-[1px] -translate-y-[1px]"></div>
            
            <div class="flex flex-col lg:flex-row gap-16 lg:gap-8 items-start">
                <div class="flex-1 w-full relative z-10">
                    <!-- Metadata Label -->
                    <div class="flex items-center gap-3 text-2xs font-mono uppercase tracking-[0.15em] text-emerald-400 mb-8">
                        <span class="w-1.5 h-1.5 bg-emerald-400 shadow-[0_0_8px_rgba(52,211,153,0.8)] animate-pulse"></span>
                        Status: Active // Core Synced
                    </div>
                    
                    <h1 class="text-4xl sm:text-5xl lg:text-7xl font-light tracking-tight leading-[1.05] text-white">
                        <span class="reveal-mask"><span class="reveal-text">Corporate</span></span><br>
                        <span class="reveal-mask"><span class="reveal-text text-neutral-400">Memory,</span></span><br>
                        <span class="reveal-mask"><span class="reveal-text">Synthesized.</span></span>
                    </h1>
                    
                    <div class="mt-12 max-w-md">
                        <p class="text-sm font-light text-neutral-400 leading-relaxed">
                            <span class="reveal-mask"><span class="reveal-text">Omni connects scattered institutional knowledge into a unified, retrieving intelligence. Secure, modular, and instantly accessible.</span></span>
                        </p>
                    </div>

                    <div class="mt-12 flex items-center gap-6">
                        <button class="relative p-[1px] clip-diagonal group inline-block">
                            <div class="absolute inset-0 bg-gradient-to-r from-emerald-500 to-blue-600 opacity-70 group-hover:opacity-100 transition-opacity"></div>
                            <div class="relative bg-black px-6 py-3 clip-diagonal text-sm font-medium flex items-center gap-3">
                                Deploy Node
                                <iconify-icon icon="solar:round-alt-arrow-right-linear" class="text-emerald-400 text-lg group-hover:translate-x-1 transition-transform"></iconify-icon>
                            </div>
                        </button>
                        <span class="text-xs font-mono text-neutral-500 uppercase tracking-widest">[ Read Docs ]</span>
                    </div>
                </div>

                <!-- Hero Graphic/Details Panel -->
                <div class="lg:w-[400px] w-full shrink-0">
                    <div class="p-[1px] bg-gradient-to-b from-white/20 to-white/0 clip-diagonal-card">
                        <div class="bg-navy-950/80 backdrop-blur-md clip-diagonal-card p-6 h-full border border-white/5 shadow-[0px_24px_24px_-12px_rgba(0,0,0,0.4)]">
                            <div class="flex justify-between items-center border-b border-white/10 pb-4 mb-4">
                                <span class="text-2xs font-mono uppercase text-neutral-500 tracking-widest">Telemetry</span>
                                <iconify-icon icon="solar:graph-up-linear" class="text-neutral-400"></iconify-icon>
                            </div>
                            <div class="space-y-4">
                                <div>
                                    <div class="text-2xs font-mono text-neutral-500 uppercase tracking-wider mb-1">Ingestion Rate</div>
                                    <div class="text-xl font-light tracking-tight">4.2 PB / ms</div>
                                </div>
                                <div class="w-full h-px bg-white/10"></div>
                                <div>
                                    <div class="text-2xs font-mono text-neutral-500 uppercase tracking-wider mb-1">Retrieval Latency</div>
                                    <div class="text-xl font-light tracking-tight text-emerald-400">12.04 ms</div>
                                </div>
                                <div class="w-full h-px bg-white/10"></div>
                                <div class="pt-2">
                                    <div class="w-full h-1 bg-white/10 overflow-hidden">
                                        <div class="w-[82%] h-full bg-gradient-to-r from-emerald-500 to-blue-500 relative">
                                            <div class="absolute right-0 top-0 bottom-0 w-4 bg-white/50 blur-sm animate-pulse"></div>
                                        </div>
                                    </div>
                                    <div class="flex justify-between mt-2 text-2xs font-mono text-neutral-500">
                                        <span>Capacity</span>
                                        <span>82%</span>
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- LOGO MARQUEE -->
        <section class="py-8 border-b border-white/10 overflow-hidden relative bg-black/20">
            <!-- Fades -->
            <div class="absolute left-0 top-0 bottom-0 w-24 bg-gradient-to-r from-navy-900 to-transparent z-10 pointer-events-none"></div>
            <div class="absolute right-0 top-0 bottom-0 w-24 bg-gradient-to-l from-navy-900 to-transparent z-10 pointer-events-none"></div>
            
            <div class="flex w-[200%] marquee-container">
                <div class="flex w-1/2 justify-around items-center opacity-50">
                    <iconify-icon icon="simple-icons:nasa" width="48"></iconify-icon>
                    <iconify-icon icon="simple-icons:spacex" width="64"></iconify-icon>
                    <iconify-icon icon="simple-icons:uber" width="48"></iconify-icon>
                    <iconify-icon icon="simple-icons:visa" width="48"></iconify-icon>
                    <iconify-icon icon="simple-icons:dji" width="48"></iconify-icon>
                    <iconify-icon icon="simple-icons:sony" width="64"></iconify-icon>
                </div>
                <div class="flex w-1/2 justify-around items-center opacity-50">
                    <iconify-icon icon="simple-icons:nasa" width="48"></iconify-icon>
                    <iconify-icon icon="simple-icons:spacex" width="64"></iconify-icon>
                    <iconify-icon icon="simple-icons:uber" width="48"></iconify-icon>
                    <iconify-icon icon="simple-icons:visa" width="48"></iconify-icon>
                    <iconify-icon icon="simple-icons:dji" width="48"></iconify-icon>
                    <iconify-icon icon="simple-icons:sony" width="64"></iconify-icon>
                </div>
            </div>
        </section>

        <!-- SPLIT LAYOUT: INTELLIGENCE -->
        <section class="relative border-b border-white/10">
            <div class="absolute top-0 left-0 w-4 h-4 border-t border-l border-white/30 -translate-x-[1px] -translate-y-[1px]"></div>
            
            <div class="grid grid-cols-1 lg:grid-cols-2 min-h-[600px]">
                <!-- Visual Side -->
                <div class="relative p-8 lg:p-16 border-b lg:border-b-0 lg:border-r border-white/10 overflow-hidden flex items-center justify-center bg-[#02040a]">
                    <div class="absolute inset-0 bg-dither opacity-50"></div>
                    <img src="assets/page-01-e534354d-c5f2-4399-a1d9-2f50338e8c47-1600w.jpg" alt="Abstract Data Wave" class="absolute inset-0 w-full h-full object-cover mix-blend-luminosity opacity-30">
                    
                    <!-- Floating Skeuomorphic Widget -->
                    <div class="relative z-10 w-full max-w-sm p-[1px] rounded-xl bg-gradient-to-br from-white/20 to-transparent transform rotate-y-[-10deg] rotate-x-[5deg] perspective-1000 shadow-[0_41.8px_33.4px_rgba(0,0,0,0.086),0_100px_80px_rgba(0,0,0,0.12)] gsap-float">
                        <div class="glass-panel rounded-[11px] p-6">
                            <div class="flex items-center gap-3 mb-6">
                                <iconify-icon icon="solar:scanner-linear" class="text-xl text-emerald-400"></iconify-icon>
                                <span class="text-xs font-mono uppercase tracking-widest">Semantic Search</span>
                            </div>
                            <div class="space-y-3">
                                <div class="h-8 bg-black/50 border border-white/10 rounded px-3 flex items-center shadow-[inset_0_1px_3px_rgba(0,0,0,0.5)]">
                                    <span class="text-xs text-neutral-500 font-mono">Q: Retrieve Q3 architecture decisions...</span>
                                </div>
                                <div class="flex gap-2">
                                    <div class="h-6 w-1/3 bg-emerald-500/20 border border-emerald-500/30 rounded flex items-center justify-center">
                                        <span class="text-2xs font-mono text-emerald-400">Match 98%</span>
                                    </div>
                                    <div class="h-6 w-2/3 bg-white/5 border border-white/10 rounded"></div>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Text Side -->
                <div class="p-8 lg:p-16 flex flex-col justify-center relative">
                    <div class="absolute top-8 right-8 text-xs font-mono text-neutral-600 tracking-widest">[ 01 ]</div>
                    
                    <h2 class="text-3xl lg:text-4xl font-light tracking-tight mb-6">
                        <span class="reveal-mask"><span class="reveal-text">Fractal contextual</span></span><br>
                        <span class="reveal-mask"><span class="reveal-text text-neutral-400">understanding.</span></span>
                    </h2>
                    
                    <p class="text-sm font-light text-neutral-400 leading-relaxed mb-10 max-w-md">
                        Omni doesn't just index keywords. It builds a multi-dimensional graph of your organization's logic, mapping intent behind communications, codebases, and strategy documents.
                    </p>
                    
                    <ul class="space-y-6">
                        <li class="flex items-start gap-4">
                            <div class="mt-1 w-5 h-5 rounded flex items-center justify-center border border-white/20 bg-white/5">
                                <iconify-icon icon="solar:database-linear" class="text-xs"></iconify-icon>
                            </div>
                            <div>
                                <h3 class="text-sm font-medium mb-1">Agnostic Ingestion</h3>
                                <p class="text-xs font-light text-neutral-500 leading-relaxed">Connects to Slack, Jira, GitHub, and Drive without schema mapping.</p>
                            </div>
                        </li>
                        <li class="flex items-start gap-4">
                            <div class="mt-1 w-5 h-5 rounded flex items-center justify-center border border-white/20 bg-white/5">
                                <iconify-icon icon="solar:cpu-linear" class="text-xs"></iconify-icon>
                            </div>
                            <div>
                                <h3 class="text-sm font-medium mb-1">Neural Synthesis</h3>
                                <p class="text-xs font-light text-neutral-500 leading-relaxed">Automatically resolves contradictions between legacy documentation and recent pull requests.</p>
                            </div>
                        </li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- NESTED CONTAINERS: ARCHITECTURE -->
        <section class="p-4 lg:p-8 border-b border-white/10 relative">
            <div class="absolute top-0 right-0 w-4 h-4 border-t border-r border-white/30 translate-x-[1px] -translate-y-[1px]"></div>
            
            <div class="p-[1px] bg-gradient-to-b from-white/10 to-transparent clip-diagonal-card">
                <div class="bg-navy-950 clip-diagonal-card p-8 lg:p-16 relative overflow-hidden">
                    <!-- Background texture inside nested container -->
                    <div class="absolute inset-0 bg-tech-grid opacity-30"></div>
                    
                    <div class="relative z-10 flex flex-col lg:flex-row justify-between items-end mb-16 gap-8">
                        <div>
                            <div class="text-xs font-mono text-neutral-600 tracking-widest mb-4">[ 02 ]</div>
                            <h2 class="text-3xl lg:text-4xl font-light tracking-tight max-w-lg">
                                Zero-trust by design.<br>
                                <span class="text-neutral-500">Air-gapped capability.</span>
                            </h2>
                        </div>
                        <button class="text-xs font-mono bg-transparent border border-white/20 text-white px-4 py-2 clip-diagonal hover:bg-white/5 transition-colors uppercase">
                            View Security Brief
                        </button>
                    </div>

                    <!-- Grid Modules -->
                    <div class="grid grid-cols-1 md:grid-cols-3 gap-4 relative z-10">
                        <!-- Card 1 -->
                        <div class="group relative p-[1px] rounded-lg bg-gradient-to-b from-white/10 to-transparent overflow-hidden">
                            <!-- Flashlight effect setup -->
                            <div class="absolute inset-0 bg-[conic-gradient(from_var(--cursor-angle,0deg),#fff,transparent_60deg,transparent_300deg,#fff)] opacity-0 group-hover:opacity-20 transition-opacity duration-300"></div>
                            
                            <div class="relative h-full bg-[#05070f] rounded-[7px] p-8 flex flex-col border border-white/5 shadow-[0px_0px_0px_1px_rgba(0,0,0,0.06),0px_12px_12px_-6px_rgba(0,0,0,0.5)]">
                                <iconify-icon icon="solar:shield-keyhole-linear" class="text-2xl text-neutral-400 mb-6"></iconify-icon>
                                <h3 class="text-sm font-medium mb-2">VPC Deployment</h3>
                                <p class="text-xs font-light text-neutral-500 leading-relaxed mt-auto">Run the entire LLM and vector database within your own cloud boundary. No data phones home.</p>
                            </div>
                        </div>

                        <!-- Card 2 -->
                        <div class="group relative p-[1px] rounded-lg bg-gradient-to-b from-white/10 to-transparent overflow-hidden">
                            <div class="absolute inset-0 bg-[conic-gradient(from_var(--cursor-angle,0deg),#fff,transparent_60deg,transparent_300deg,#fff)] opacity-0 group-hover:opacity-20 transition-opacity duration-300"></div>
                            <div class="relative h-full bg-[#05070f] rounded-[7px] p-8 flex flex-col border border-white/5 shadow-[0px_0px_0px_1px_rgba(0,0,0,0.06),0px_12px_12px_-6px_rgba(0,0,0,0.5)]">
                                <iconify-icon icon="solar:users-group-two-rounded-linear" class="text-2xl text-neutral-400 mb-6"></iconify-icon>
                                <h3 class="text-sm font-medium mb-2">RBAC Enforcement</h3>
                                <p class="text-xs font-light text-neutral-500 leading-relaxed mt-auto">Memory retrieval strictly respects source-system permissions. If a user can't see it in Drive, they can't ask Omni.</p>
                            </div>
                        </div>

                        <!-- Card 3 -->
                        <div class="group relative p-[1px] rounded-lg bg-gradient-to-b from-white/10 to-transparent overflow-hidden">
                            <div class="absolute inset-0 bg-[conic-gradient(from_var(--cursor-angle,0deg),#fff,transparent_60deg,transparent_300deg,#fff)] opacity-0 group-hover:opacity-20 transition-opacity duration-300"></div>
                            <div class="relative h-full bg-[#05070f] rounded-[7px] p-8 flex flex-col border border-white/5 shadow-[0px_0px_0px_1px_rgba(0,0,0,0.06),0px_12px_12px_-6px_rgba(0,0,0,0.5)]">
                                <iconify-icon icon="solar:history-linear" class="text-2xl text-neutral-400 mb-6"></iconify-icon>
                                <h3 class="text-sm font-medium mb-2">Immutable Audit</h3>
                                <p class="text-xs font-light text-neutral-500 leading-relaxed mt-auto">Cryptographically signed logs of every query, synthesis, and source retrieval for compliance.</p>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- EDITORIAL TECH: THE CORE -->
        <section class="py-24 px-6 lg:px-16 relative">
            <div class="absolute top-0 left-0 w-4 h-4 border-t border-l border-white/30 -translate-x-[1px] -translate-y-[1px]"></div>
            <div class="absolute bottom-0 right-0 w-4 h-4 border-b border-r border-white/30 translate-x-[1px] translate-y-[1px]"></div>
            
            <div class="flex flex-col lg:flex-row gap-16 items-center">
                <div class="flex-1 order-2 lg:order-1">
                    <div class="text-xs font-mono text-neutral-600 tracking-widest mb-6">[ 03 ]</div>
                    <h2 class="text-4xl lg:text-5xl font-light tracking-tight mb-8 leading-[1.1]">
                        <span class="reveal-mask"><span class="reveal-text">Built for the</span></span><br>
                        <span class="reveal-mask"><span class="reveal-text">complexity of scale.</span></span>
                    </h2>
                    
                    <div class="space-y-6 text-sm font-light text-neutral-400 max-w-md">
                        <p>Unlike generic AI wrappers, Omni is built on a custom deterministic retrieval engine that prioritizes factual accuracy over conversational fluency.</p>
                        <p>It generates citations for every assertion, linking directly to the specific lines of code, Slack threads, or policy documents that informed its response.</p>
                    </div>

                    <div class="mt-10 pt-10 border-t border-white/10 grid grid-cols-2 gap-8">
                        <div>
                            <div class="text-3xl font-light text-white tracking-tight">100M+</div>
                            <div class="text-2xs font-mono uppercase text-neutral-500 mt-2">Tokens Context Window</div>
                        </div>
                        <div>
                            <div class="text-3xl font-light text-white tracking-tight">0%</div>
                            <div class="text-2xs font-mono uppercase text-neutral-500 mt-2">Hallucination Guarantee*</div>
                        </div>
                    </div>
                </div>

                <div class="flex-1 order-1 lg:order-2 w-full">
                    <!-- Image framed as a technical plate -->
                    <div class="p-[1px] bg-gradient-to-bl from-white/20 to-transparent relative">
                        <div class="absolute -top-3 -right-3 text-2xs font-mono text-neutral-600">FIG_01</div>
                        <div class="bg-black p-2 border border-white/5">
                            <img src="assets/page-02-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg" alt="Futuristic Structure" class="w-full aspect-[4/3] object-cover grayscale opacity-80">
                        </div>
                        <!-- Technical overlay lines -->
                        <div class="absolute top-10 -left-6 w-12 h-[1px] bg-white/20"></div>
                        <div class="absolute bottom-10 -right-6 w-12 h-[1px] bg-white/20"></div>
                    </div>
                </div>
            </div>
        </section>

        <!-- FOOTER -->
        <footer class="border-t border-white/10 py-8 px-8 flex flex-col md:flex-row justify-between items-center gap-4 bg-[#010205] relative z-20">
            <div class="flex items-center gap-3">
                <div class="w-1.5 h-1.5 bg-neutral-600"></div>
                <span class="text-xs font-mono uppercase tracking-widest text-neutral-500">Omni Systems Inc. © 2024</span>
            </div>
            <div class="flex gap-6 text-xs font-mono uppercase tracking-widest text-neutral-500">
                <a href="#" class="hover:text-white transition-colors">Documentation</a>
                <a href="#" class="hover:text-white transition-colors">Status</a>
                <a href="#" class="hover:text-white transition-colors">Privacy</a>
            </div>
        </footer>
    </main>

    <!-- Scripts -->
    <script>
        // --- 1. Three.js WebGL Background (Organic Morphing Entity / AI Core) ---
        const initWebGL = () => {
            const canvas = document.getElementById('webgl-canvas');
            const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: true });
            renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
            renderer.setSize(window.innerWidth, window.innerHeight);

            const scene = new THREE.Scene();
            scene.fog = new THREE.Fog('#020617', 3, 10);

            // Shift camera right on desktop to leave room for text
            const camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 0.1, 100);
            camera.position.z = 5;
            camera.position.x = window.innerWidth > 1024 ? 1.5 : 0;

            // Geometry: High segment sphere for smooth noise displacement
            const geometry = new THREE.SphereGeometry(1.5, 128, 128);

            // Shader Material (Simplex Noise + Iridescent Fresnel)
            const material = new THREE.ShaderMaterial({
                uniforms: {
                    uTime: { value: 0 },
                    uMouse: { value: new THREE.Vector2(0, 0) }
                },
                vertexShader: `
                    uniform float uTime;
                    varying vec2 vUv;
                    varying vec3 vNormal;
                    varying vec3 vPosition;

                    // Simplex 3D Noise function (compact)
                    vec4 permute(vec4 x){return mod(((x*34.0)+1.0)*x, 289.0);}
                    vec4 taylorInvSqrt(vec4 r){return 1.79284291400159 - 0.85373472095314 * r;}
                    float snoise(vec3 v){ 
                        const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
                        const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
                        vec3 i  = floor(v + dot(v, C.yyy) );
                        vec3 x0 = v - i + dot(i, C.xxx) ;
                        vec3 g = step(x0.yzx, x0.xyz);
                        vec3 l = 1.0 - g;
                        vec3 i1 = min( g.xyz, l.zxy );
                        vec3 i2 = max( g.xyz, l.zxy );
                        vec3 x1 = x0 - i1 + 1.0 * C.xxx;
                        vec3 x2 = x0 - i2 + 2.0 * C.xxx;
                        vec3 x3 = x0 - 1.0 + 3.0 * C.xxx;
                        i = mod(i, 289.0 ); 
                        vec4 p = permute( permute( permute( 
                                    i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
                                + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) 
                                + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
                        float n_ = 1.0/7.0;
                        vec3  ns = n_ * D.wyz - D.xzx;
                        vec4 j = p - 49.0 * floor(p * ns.z *ns.z);
                        vec4 x_ = floor(j * ns.z);
                        vec4 y_ = floor(j - 7.0 * x_ );
                        vec4 x = x_ *ns.x + ns.yyyy;
                        vec4 y = y_ *ns.x + ns.yyyy;
                        vec4 h = 1.0 - abs(x) - abs(y);
                        vec4 b0 = vec4( x.xy, y.xy );
                        vec4 b1 = vec4( x.zw, y.zw );
                        vec4 s0 = floor(b0)*2.0 + 1.0;
                        vec4 s1 = floor(b1)*2.0 + 1.0;
                        vec4 sh = -step(h, vec4(0.0));
                        vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
                        vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
                        vec3 p0 = vec3(a0.xy,h.x);
                        vec3 p1 = vec3(a0.zw,h.y);
                        vec3 p2 = vec3(a1.xy,h.z);
                        vec3 p3 = vec3(a1.zw,h.w);
                        vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
                        p0 *= norm.x; p1 *= norm.y; p2 *= norm.z; p3 *= norm.w;
                        vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
                        m = m * m;
                        return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3) ) );
                    }

                    void main() {
                        vUv = uv;
                        vNormal = normalize(normalMatrix * normal);
                        
                        // Displacement
                        float noise = snoise(vec3(position.x * 1.2 + uTime * 0.15, position.y * 1.2, position.z * 1.2));
                        vec3 newPosition = position + normal * (noise * 0.3);
                        
                        vPosition = (modelViewMatrix * vec4(newPosition, 1.0)).xyz;
                        gl_Position = projectionMatrix * modelViewMatrix * vec4(newPosition, 1.0);
                    }
                `,
                fragmentShader: `
                    varying vec2 vUv;
                    varying vec3 vNormal;
                    varying vec3 vPosition;

                    void main() {
                        // Calculate Fresnel
                        vec3 viewDir = normalize(-vPosition);
                        float fresnel = pow(1.0 - clamp(dot(viewDir, vNormal), 0.0, 1.0), 2.5);
                        
                        // Iridescent Palette (Dark core, Emerald/Blue edges)
                        vec3 coreColor = vec3(0.01, 0.02, 0.05);
                        vec3 edgeColor = mix(vec3(0.1, 0.5, 0.8), vec3(0.2, 0.9, 0.6), vUv.y);
                        
                        vec3 finalColor = mix(coreColor, edgeColor, fresnel * 1.5);
                        
                        gl_FragColor = vec4(finalColor, 0.8);
                    }
                `,
                transparent: true,
                wireframe: false
            });

            const mesh = new THREE.Mesh(geometry, material);
            scene.add(mesh);

            // Interaction state
            let mouseX = 0;
            let mouseY = 0;
            let targetX = 0;
            let targetY = 0;

            document.addEventListener('mousemove', (e) => {
                mouseX = (e.clientX / window.innerWidth) * 2 - 1;
                mouseY = -(e.clientY / window.innerHeight) * 2 + 1;
            });

            const clock = new THREE.Clock();

            const tick = () => {
                const elapsedTime = clock.getElapsedTime();
                
                // Update Shader Time
                material.uniforms.uTime.value = elapsedTime;

                // Breathing Y oscillation
                mesh.position.y = Math.sin(elapsedTime * 0.5) * 0.1;

                // Mouse parallax smoothing
                targetX = mouseX * 0.2;
                targetY = mouseY * 0.2;
                mesh.rotation.y += 0.05 * (targetX - mesh.rotation.y);
                mesh.rotation.x += 0.05 * (targetY - mesh.rotation.x);

                renderer.render(scene, camera);
                window.requestAnimationFrame(tick);
            };

            tick();

            window.addEventListener('resize', () => {
                camera.aspect = window.innerWidth / window.innerHeight;
                camera.position.x = window.innerWidth > 1024 ? 1.5 : 0;
                camera.updateProjectionMatrix();
                renderer.setSize(window.innerWidth, window.innerHeight);
            });
        };

        // --- 2. GSAP Animations & Interactions ---
        const initGSAP = () => {
            gsap.registerPlugin(ScrollTrigger);

            // Masked Word Reveals
            const revealTexts = document.querySelectorAll('.reveal-text');
            revealTexts.forEach((text) => {
                gsap.to(text, {
                    y: "0%",
                    ease: "power4.out",
                    duration: 1.2,
                    scrollTrigger: {
                        trigger: text.parentElement,
                        start: "top 90%",
                    }
                });
            });

            // Float Animation for elements
            gsap.to(".gsap-float", {
                y: -15,
                rotationX: "+=2",
                rotationY: "+=2",
                duration: 4,
                repeat: -1,
                yoyo: true,
                ease: "sine.inOut"
            });

            // Logo Marquee Loop
            gsap.to(".marquee-container", {
                xPercent: -50,
                ease: "none",
                duration: 20,
                repeat: -1
            });
        };

        // --- 3. Dynamic Flashlight Effect ---
        const initFlashlight = () => {
            const cards = document.querySelectorAll('.group');
            cards.forEach(card => {
                card.addEventListener('mousemove', (e) => {
                    const rect = card.getBoundingClientRect();
                    const x = e.clientX - rect.left;
                    const y = e.clientY - rect.top;
                    const cx = rect.width / 2;
                    const cy = rect.height / 2;
                    
                    // Calculate angle
                    let angle = Math.atan2(y - cy, x - cx) * (180 / Math.PI) + 90;
                    if (angle < 0) angle += 360;
                    
                    card.style.setProperty('--cursor-angle', `${angle}deg`);
                });
            });
        };

        // Initialize all
        document.addEventListener('DOMContentLoaded', () => {
            initWebGL();
            initGSAP();
            initFlashlight();
        });
    </script>
</body>
</html>
";
    const assetFiles = ["assets/page-01-e534354d-c5f2-4399-a1d9-2f50338e8c47-1600w.jpg","assets/page-02-724142aa-44a6-48d3-9cf3-761e00d05b78-1600w.jpg"];
    const runtimeFiles = ["../../../../assets/runtime/runtime-027051effa47-gsap-min.js","../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js","../../../../assets/runtime/runtime-25023b521d77-three-min.js","../../../../assets/runtime/runtime-689ca8dda44c-scrolltrigger-min.js","../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"];
    const frame = document.getElementById("neuform-demo");
    const decodeBytes = (value) => Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
    const decode = (value) => new TextDecoder().decode(decodeBytes(value));
    const encodeBytes = (bytes) => {
      let binary = "";
      for (let index = 0; index < bytes.length; index += 32768) {
        binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
      }
      return btoa(binary);
    };
    const mediaTypes = {
      avif: "image/avif",
      gif: "image/gif",
      jpg: "image/jpeg",
      jpeg: "image/jpeg",
      mp4: "video/mp4",
      png: "image/png",
      webm: "video/webm",
      webp: "image/webp"
    };
    const loadAsset = async (file) => {
      const response = await fetch(file, { cache: "no-store", credentials: "omit", redirect: "error" });
      if (!response.ok) throw new Error("Could not load local demo asset: " + file);
      const extension = file.split(".").pop().toLowerCase();
      const contentType = mediaTypes[extension] || "application/octet-stream";
      const bytes = new Uint8Array(await response.arrayBuffer());
      return { base64: encodeBytes(bytes), contentType, file, kind: "asset" };
    };
    Promise.allSettled(assetFiles.map(loadAsset)).then((results) => {
      const runtimeSources = runtimeFiles.map((file) => new URL(file, location.href).href).join(" ");
      const source = decode(encodedHtml).replace("__NEUFORM_RUNTIME_SOURCES__", runtimeSources);
      const mediaAssets = [];
      for (const result of results) {
        if (result.status !== "fulfilled") continue;
        mediaAssets.push(result.value);
      }
      frame.addEventListener("load", () => {
        frame.contentWindow.postMessage({ type: "neuform-assets-v1", assets: mediaAssets }, "*");
      }, { once: true });
      frame.srcdoc = source;
    }).catch((error) => {
      document.body.innerHTML = '<div class="error">Unable to load this sandboxed demo.</div>';
      console.error(error);
    });
  </script>
</body>
</html>

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Meng To

Publisher

Meng To (Community)

Source

MengTo/Skills · agent-skills/web-design/book-serif-index · commit 5ea1661

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by Meng To.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download book-serif-index.zip