hanzo.ai/app/(marketing)/stream/view.tsx

'use client'

import type { ReactNode } from 'react'
import { ArrowRight, BarChart3, GitBranch, Layers, Radio, Server, Shield, Zap } from 'lucide-react'
import { OSSRevenueBanner } from '@/components/oss/OSSRevenueBanner'
import { ProductLanding } from '@/components/product/ProductLanding'
import { ProductFooter } from '@/components/products/ProductFooter'
import { phrase } from '@hanzo/i18n'

/**
 * Stream, through the ONE product kit.
 *
 * One of NINE pages — console, insights, kms, kv, mq, pubsub, sql, storage,
 * stream — that shared a class set 100%: the same hero, stat row, six-card
 * grid, terminal and call to action, written out nine times in ~310 utility
 * classes each. They now pass one typed props object to `ProductLanding` and
 * carry zero layout classes. See LLM.md, "Tailwind is NOT gone", for the rule.
 *
 * EVERY WORD IS THE ONE THAT WAS HERE, the four stat tiles included: 28 of the
 * group's 36 carry a port, a version, a licence or a coding the prose does not
 * (measured), so unlike /ledger's four they are not restatements and they stay.
 *
 * One fix the move makes by construction: ProductFooter sat INSIDE the final
 * card's `max-w-4xl` wrapper on all nine, so the OSS attribution and deploy
 * block rendered narrower here than on every other product page.
 */

export default function StreamPage({ source }: { source: ReactNode }) {
  return (
    <>
      <ProductLanding
        badge={phrase("Kafka Wire Protocol")}
        badgeIcon={Radio}
        title={"Hanzo Stream"}
        tagline={phrase("A Kafka port in front of Hanzo PubSub")}
        lede={phrase("Stream speaks the Kafka binary protocol on 9092 and stores nothing itself. A produce becomes a message in a durable PubSub stream — topic orders, partition 0, is the stream kafka-orders-0 — and a fetch reads it back out. Your producers and consumers connect unchanged, and it runs inside your cluster, next to the store it fronts.")}
        ctas={[
          { label: "GitHub", href: "https://github.com/hanzoai/stream" },
        ]}
        what={{
          title: phrase("Your clients, our store"),
          sub: phrase("Keep the producers and consumers you have. Drop the cluster underneath them."),
          pillars: [
            {
              icon: Layers,
              title: phrase("It speaks Kafka"),
              body: phrase("Produce, Fetch, ListOffsets, Metadata, OffsetCommit, OffsetFetch, FindCoordinator, JoinGroup, SyncGroup, Heartbeat, CreateTopics and ApiVersions, at the versions modern clients negotiate. kafka-python, sarama, confluent-kafka and franz-go all connect."),
            },
            {
              icon: Zap,
              title: phrase("The log lives in PubSub"),
              body: phrase("One topic partition is one durable PubSub stream. Retention, replicas and disk are that stream's settings, so the thing actually holding your events is a system you already run and already back up."),
            },
            {
              icon: Server,
              title: phrase("Nothing to operate"),
              body: phrase("One Go binary that keeps no state of its own. Restart it, run several, roll it mid-deploy — the log is somewhere else, so the gateway is never the piece you are afraid to touch."),
            },
            {
              icon: GitBranch,
              title: phrase("Offsets survive a restart"),
              body: phrase("A group's committed offsets live in a PubSub key-value bucket, so a consumer that dies comes back where it left off instead of at the top. Ask for an offset that has aged out and you get OFFSET_OUT_OF_RANGE, so the client resets rather than hangs."),
            },
            {
              icon: BarChart3,
              title: phrase("Offsets are stamped, not inferred"),
              body: phrase("Every Kafka offset is written into the record batch header when the batch is produced, and read straight back from there. Deriving them from the store's own sequence numbers works right up until the sequence has gaps in it — and then one record can make every fetch after it unreadable."),
            },
            {
              icon: Shield,
              title: phrase("Bad batches are refused on arrival"),
              body: phrase("A produce whose batch chain does not line up is refused with INVALID_RECORD instead of being written and discovered later by a consumer that cannot get past it. The scan that recovers a partition's bounds is capped, so a damaged topic degrades rather than stalls."),
            },
          ],
        }}
        stats={{
          items: [
            { value: "Kafka", label: phrase("Wire protocol") },
            { value: "PubSub", label: phrase("Holds the log") },
            { value: phrase("Stateless"), label: phrase("No broker disk") },
            { value: phrase("Durable"), label: phrase("At-least-once") },
          ],
        }}
        code={{
          head: { title: phrase("One line changes: the bootstrap server") },
          name: "producer.py",
          source,
        }}
        finalCta={{
          title: phrase("Point the bootstrap server at it"),
          sub: phrase("The clients stay as they are. The cluster underneath them goes away."),
          buttons: [
            { label: phrase("View on GitHub"), href: "https://github.com/hanzoai/stream" },
          ],
        }}
      >
        <OSSRevenueBanner />
      </ProductLanding>
      <ProductFooter slug={"stream"} name={"Stream"} />
    </>
  )
}