;; ---------------------------------------------------------------------------
;; SX-Activity: Federated SX over ActivityPub
;; ---------------------------------------------------------------------------

(defcomp ()
  (~docs/page :title "SX-Activity"

    (~docs/section :title "Context" :id "context"
      (p "The web is six incompatible formats duct-taped together: HTML for structure, CSS for style, JavaScript for behavior, JSON for data, server languages for backend logic, build tools for compilation. Moving anything between layers requires serialization, template languages, API contracts, and glue code. Federation (ActivityPub) adds a seventh — JSON-LD — which is inert data that every consumer must interpret from scratch and wrap in their own UI.")
      (p "SX is already one evaluable format that does all six. A component definition is simultaneously structure, style (components apply classes and respond to data), behavior (event handlers), data (the AST " (em "is") " data), server-renderable (Python evaluator), and client-renderable (JS evaluator). The pieces already exist: content-addressed DAG execution (artdag), IPFS storage with CIDs, OpenTimestamps Bitcoin anchoring, boundary-enforced sandboxing.")
      (p "SX-Activity wires these together into a new web. Everything — content, UI components, markdown parsers, syntax highlighters, validation logic, media, processing pipelines — is the same executable format, stored on a content-addressed network, running within each participant's own security context. " (strong "The wire format is the programming language is the component system is the package manager.")))

    (~docs/section :title "Current State" :id "current-state"
      (ul (~tw :tokens "space-y-2 text-stone-700 list-disc pl-5")
        (li (strong "ActivityPub: ") "Full implementation — virtual per-app actors, HTTP signatures, webfinger, inbox/outbox, followers/following, delivery with idempotent logging.")
        (li (strong "Activity bus: ") "Unified event bus with NOTIFY/LISTEN wakeup, at-least-once delivery, handler registry keyed by (activity_type, object_type).")
        (li (strong "Content addressing: ") "artdag nodes use SHA3-256 hashing. Cache layer tracks IPFS CIDs. IPFSPin model tracks pinned content across domains.")
        (li (strong "Bitcoin anchoring: ") "APAnchor model — Merkle tree of activities, OpenTimestamps proof CID, Bitcoin txid. Infrastructure exists but isn't wired to all activity types.")
        (li (strong "SX wire format: ") "Server serializes to SX source via _aser, client parses and renders. Component caching via localStorage + content hashes.")
        (li (strong "Boundary enforcement: ") "SX_BOUNDARY_STRICT=1 validates all primitives at registration. Pure components can't do IO — safe to load from untrusted sources.")))

    ;; -----------------------------------------------------------------------
    ;; Phase 1: SX Wire Format for Activities
    ;; -----------------------------------------------------------------------

    (~docs/section :title "Phase 1: SX Wire Format for Activities" :id "phase-1"

      (div (~tw :tokens "rounded border border-violet-200 bg-violet-50 p-4 mb-4")
        (p (~tw :tokens "text-violet-900 font-medium") "What it enables")
        (p (~tw :tokens "text-violet-800") "Activities expressed as s-expressions instead of JSON-LD. Same semantics as ActivityStreams, but compact, parseable, and directly evaluable. Dual-format support for backward compatibility with existing AP servers."))

      (~docs/subsection :title "The Problem"
        (p "JSON-LD activities are verbose and require context resolution:")
        (~docs/code :src (highlight "{\"@context\": \"https://www.w3.org/ns/activitystreams\",\n \"type\": \"Create\",\n \"actor\": \"https://example.com/users/alice\",\n \"object\": {\n   \"type\": \"Note\",\n   \"content\": \"<p>Hello world</p>\",\n   \"attributedTo\": \"https://example.com/users/alice\"\n }}" "json"))
        (p "Every consumer parses JSON, resolves @context, extracts fields, then builds their own UI around the raw data. The content is HTML embedded in a JSON string — two formats nested, neither evaluable."))

      (~docs/subsection :title "SX Activity Format"
        (p "The same activity as SX:")
        (~docs/code :src (highlight "(Create\n  :actor \"https://example.com/users/alice\"\n  :published \"2026-03-06T12:00:00Z\"\n  :object (Note\n    :attributed-to \"https://example.com/users/alice\"\n    :content (p \"Hello world\")\n    :media-type \"text/sx\"))" "lisp"))
        (p "The content isn't a string containing markup — it " (em "is") " markup. The receiving server can evaluate it directly. The Note's content is a renderable SX expression."))

      (~docs/subsection :title "Approach"
        (div (~tw :tokens "space-y-4")
          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "1. Activity vocabulary in SX")
            (p "Map ActivityStreams types to SX symbols. Activities are lists with a type head and keyword properties:")
            (~docs/code :src (highlight ";; Core activity types\n(Create :actor ... :object ...)\n(Update :actor ... :object ...)\n(Delete :actor ... :object ...)\n(Follow :actor ... :object ...)\n(Like   :actor ... :object ...)\n(Announce :actor ... :object ...)\n\n;; Object types\n(Note :content ... :attributed-to ...)\n(Article :name ... :content ... :summary ...)\n(Image :url ... :media-type ... :cid ...)\n(Collection :total-items ... :items ...)" "lisp")))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "2. Content negotiation")
            (p "Inbox accepts both formats. " (code "Accept: text/sx") " gets SX, " (code "Accept: application/activity+json") " gets JSON-LD. Outbox serves both. SX-native servers negotiate SX; legacy Mastodon/Pleroma servers get JSON-LD as today."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "3. Bidirectional translation")
            (p "Lossless mapping between JSON-LD and SX activity formats. Translate at the boundary — internal processing always uses SX. The existing " (code "APActivity") " model gains an " (code "sx_source") " column storing the canonical SX representation."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "4. HTTP Signatures over SX")
            (p "Same RSA signature mechanism. Digest header computed over the SX body. Existing keypair infrastructure unchanged."))))

      (~docs/subsection :title "Verification"
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li "Round-trip: SX → JSON-LD → SX produces identical output")
          (li "Legacy AP servers receive valid JSON-LD (Mastodon can display the post)")
          (li "SX-native servers receive evaluable SX (client can render directly)")
          (li "HTTP signatures verify over SX bodies"))))

    ;; -----------------------------------------------------------------------
    ;; Phase 2: Content-Addressed Components on IPFS
    ;; -----------------------------------------------------------------------

    (~docs/section :title "Phase 2: Content-Addressed Components on IPFS" :id "phase-2"

      (div (~tw :tokens "rounded border border-violet-200 bg-violet-50 p-4 mb-4")
        (p (~tw :tokens "text-violet-900 font-medium") "What it enables")
        (p (~tw :tokens "text-violet-800") "Component definitions stored on IPFS, referenced by CID. Any server can publish components. Any browser can fetch them. No central registry — content addressing IS the registry."))

      (~docs/subsection :title "The Insight"
        (p "SX components are pure functions — they take data and return markup. They can't do IO (boundary enforcement guarantees this). That means they're " (strong "safe to load from any source") ". And if they're content-addressed, the CID " (em "is") " the identity — you don't need to trust the source, you just verify the hash.")
        (p "Currently, component definitions travel with each page via " (code "<script type=\"text/sx\" data-components>") ". Each server bundles its own. With IPFS, components become shared infrastructure — define once, use everywhere."))

      (~docs/subsection :title "Approach"
        (div (~tw :tokens "space-y-4")
          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "1. Component CID computation")
            (p "Each " (code "defcomp") " definition gets a content address:")
            (~docs/code :src (highlight ";; Component source\n(defcomp ~plans/sx-activity/card (&key title &rest children)\n  (div :class \"border rounded p-4\"\n    (h2 title) children))\n\n;; CID = SHA3-256 of canonical serialized form\n;; → bafy...abc123\n;; Stored: ipfs://bafy...abc123 → component source" "lisp"))
            (p "Canonical form: normalize whitespace, sort keyword args alphabetically, strip comments. Same component always produces same CID regardless of formatting."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "2. Component references in activities")
            (p "Activities declare which components they need by CID:")
            (~docs/code :src (highlight "(Create\n  :actor \"https://rose-ash.com/users/alice\"\n  :requires (list\n    \"bafy...card\"      ;; ~plans/sx-activity/card component\n    \"bafy...avatar\")   ;; ~shared:misc/avatar component\n  :object (Note\n    :content (~plans/sx-activity/card :title \"Hello\"\n      (~shared:misc/avatar :src \"ipfs://bafy...photo\")\n      (p \"This renders with the card component.\"))))" "lisp"))
            (p "The receiving browser fetches missing components from IPFS, verifies CIDs, registers them, then renders the content."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "3. IPFS component resolution")
            (p "Client-side resolution pipeline:")
            (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
              (li "Check localStorage cache (keyed by CID — cache-forever semantics)")
              (li "Check local IPFS node if running (ipfs cat)")
              (li "Fetch from IPFS gateway (configurable, default: dweb.link)")
              (li "Verify SHA3-256 matches CID")
              (li "Parse, register in component env, render")))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "4. Component publication")
            (p "Server-side: on component registration, compute CID and pin to IPFS. Track in " (code "IPFSPin") " model (already exists). Publish component availability via AP outbox:")
            (~docs/code :src (highlight "(Create\n  :actor \"https://rose-ash.com/apps/market\"\n  :object (SxComponent\n    :name \"~product-card\"\n    :cid \"bafy...productcard\"\n    :version \"1.0.0\"\n    :deps (list \"bafy...card\" \"bafy...price-tag\")))" "lisp")))))

      (~docs/subsection :title "Verification"
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li "Component pinned to IPFS → fetchable via gateway → CID verifies")
          (li "Browser renders federated post using IPFS-fetched components")
          (li "Modified component → different CID → old content still renders with old version")
          (li "Boundary enforcement: IPFS-loaded component cannot call IO primitives"))))

    ;; -----------------------------------------------------------------------
    ;; Phase 3: Federated Media & Content Store
    ;; -----------------------------------------------------------------------

    (~docs/section :title "Phase 3: Federated Media & Content Store" :id "phase-3"

      (div (~tw :tokens "rounded border border-violet-200 bg-violet-50 p-4 mb-4")
        (p (~tw :tokens "text-violet-900 font-medium") "What it enables")
        (p (~tw :tokens "text-violet-800") "All media (images, video, audio, DAG outputs) stored content-addressed on IPFS. Activities reference media by CID. No hotlinking, no broken links, no dependence on the origin server staying online."))

      (~docs/subsection :title "Current Mechanism"
        (p "artdag already content-addresses all DAG outputs with SHA3-256 and tracks IPFS CIDs in " (code "IPFSPin") ". But media in the web platform (blog images, product photos, event banners) is stored as regular files on the origin server. Federated posts include " (code "url") " fields pointing to the origin — if the server goes down, the media is gone."))

      (~docs/subsection :title "Approach"
        (div (~tw :tokens "space-y-4")
          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "1. Media CID pipeline")
            (p "On upload: hash content → pin to IPFS → store CID in database. Activities reference media by CID alongside URL fallback:")
            (~docs/code :src (highlight "(Image\n  :cid \"bafy...photo123\"\n  :url \"https://rose-ash.com/media/photo.jpg\"  ;; fallback\n  :media-type \"image/jpeg\"\n  :width 1200 :height 800)" "lisp")))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "2. DAG output federation")
            (p "artdag processing results (rendered video, processed images) already have CIDs. Federate them as activities:")
            (~docs/code :src (highlight "(Create\n  :actor \"https://rose-ash.com/users/alice\"\n  :object (Artwork\n    :name \"Sunset Remix\"\n    :cid \"bafy...artwork\"\n    :dag-cid \"bafy...dag\"       ;; full DAG for reproduction\n    :media-type \"video/mp4\"\n    :sources (list\n      (Image :cid \"bafy...src1\" :attribution \"...\")\n      (Image :cid \"bafy...src2\" :attribution \"...\"))))" "lisp"))
            (p "The " (code ":dag-cid") " lets anyone re-execute the processing pipeline. The artwork is both a result and a reproducible recipe."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "3. Shared SX content store")
            (p "Not just components and media — full page content can be content-addressed. An Article's body is SX, pinned to IPFS:")
            (~docs/code :src (highlight "(Article\n  :name \"Why S-Expressions\"\n  :content-cid \"bafy...article-body\"  ;; SX source on IPFS\n  :requires (list \"bafy...doc-page\" \"bafy...code-block\")\n  :summary \"Why SX uses s-expressions instead of HTML.\")" "lisp"))
            (p "The content outlives the server. Anyone with the CID can fetch, parse, and render the article with its original components."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "4. Progressive resolution")
            (p "Client resolves content progressively:")
            (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
              (li "Inline content renders immediately")
              (li "CID-referenced content shows placeholder → fetches from IPFS → renders")
              (li "Large media uses IPFS streaming (chunked CIDs)")
              (li "Integrates with Phase 6 of isomorphic plan (streaming/suspense)")))))

      (~docs/subsection :title "Verification"
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li "Origin server offline → content still resolvable via IPFS gateway")
          (li "DAG CID → re-executing DAG produces identical output")
          (li "Media CID verifies → tampered content rejected"))))

    ;; -----------------------------------------------------------------------
    ;; Phase 4: Component Registry & Discovery
    ;; -----------------------------------------------------------------------

    (~docs/section :title "Phase 4: Component Registry & Discovery" :id "phase-4"

      (div (~tw :tokens "rounded border border-violet-200 bg-violet-50 p-4 mb-4")
        (p (~tw :tokens "text-violet-900 font-medium") "What it enables")
        (p (~tw :tokens "text-violet-800") "Federated component discovery. Servers publish component collections. Other servers follow component feeds. Like npm, but federated, content-addressed, and the packages are safe to run (pure functions, no IO)."))

      (~docs/subsection :title "Approach"
        (div (~tw :tokens "space-y-4")
          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "1. Component collections as AP actors")
            (p "Each server exposes a component registry actor:")
            (~docs/code :src (highlight "(Service\n  :id \"https://rose-ash.com/sx-registry\"\n  :type \"SxComponentRegistry\"\n  :name \"Rose Ash Components\"\n  :outbox \"https://rose-ash.com/sx-registry/outbox\"\n  :followers \"https://rose-ash.com/sx-registry/followers\")" "lisp"))
            (p "Follow the registry to receive component updates. The outbox is a chronological feed of Create/Update/Delete activities for components."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "2. Component metadata")
            (~docs/code :src (highlight "(SxComponent\n  :name \"~data-table\"\n  :cid \"bafy...datatable\"\n  :version \"2.1.0\"\n  :deps (list \"bafy...sortable\" \"bafy...paginator\")\n  :params (list\n    (dict :name \"rows\" :type \"list\" :required true)\n    (dict :name \"columns\" :type \"list\" :required true)\n    (dict :name \"sortable\" :type \"boolean\" :default false))\n  :css-atoms (list :border :rounded :p-4 :text-sm)\n  :preview-cid \"bafy...screenshot\"\n  :license \"MIT\")" "lisp"))
            (p "Dependencies are transitive CID references. CSS atoms declare which CSSX rules the component needs. Preview CID is a screenshot for registry browsing."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "3. Discovery protocol")
            (p "Webfinger-style lookup for components by name:")
            (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
              (li "Local registry: check own component env first")
              (li "Followed registries: check cached feeds from followed registries")
              (li "Global search: query known registries by component name")
              (li "CID resolution: if you have a CID, skip discovery — fetch directly from IPFS")))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "4. Version resolution")
            (p "Components are immutable (CID = identity). \"Updating\" a component publishes a new CID. Activities reference specific CIDs, so old content always renders correctly. The registry tracks version history:")
            (~docs/code :src (highlight "(Update\n  :actor \"https://rose-ash.com/sx-registry\"\n  :object (SxComponent\n    :name \"~card\"\n    :cid \"bafy...card-v2\"        ;; new version\n    :replaces \"bafy...card-v1\"   ;; previous version\n    :changelog \"Added subtitle slot\"))" "lisp")))))

      (~docs/subsection :title "Verification"
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li "Follow registry → receive component Create activities → components available locally")
          (li "Render post using component from foreign registry → works")
          (li "Old post referencing old CID → still renders correctly with old version"))))

    ;; -----------------------------------------------------------------------
    ;; Phase 5: Bitcoin-Anchored Provenance
    ;; -----------------------------------------------------------------------

    (~docs/section :title "Phase 5: Bitcoin-Anchored Provenance" :id "phase-5"

      (div (~tw :tokens "rounded border border-violet-200 bg-violet-50 p-4 mb-4")
        (p (~tw :tokens "text-violet-900 font-medium") "What it enables")
        (p (~tw :tokens "text-violet-800") "Cryptographic proof that content existed at a specific time, authored by a specific actor. Leverages the existing APAnchor/OpenTimestamps infrastructure. Unforgeable, independently verifiable, survives server shutdown."))

      (~docs/subsection :title "Current Mechanism"
        (p "The " (code "APAnchor") " model already batches activities into Merkle trees, stores the tree on IPFS, creates an OpenTimestamps proof, and records the Bitcoin txid. This runs but isn't surfaced to users or integrated with the full activity lifecycle."))

      (~docs/subsection :title "Approach"
        (div (~tw :tokens "space-y-4")
          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "1. Automatic anchoring pipeline")
            (p "Every SX activity gets queued for anchoring. Batch processor runs periodically:")
            (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
              (li "Collect pending activities (content CIDs + actor signatures)")
              (li "Build Merkle tree of activity hashes")
              (li "Pin Merkle tree to IPFS → tree CID")
              (li "Submit tree root to OpenTimestamps calendar servers")
              (li "When Bitcoin confirmation arrives: store txid, update activities with anchor reference")))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "2. Provenance chain in activities")
            (~docs/code :src (highlight "(Create\n  :actor \"https://rose-ash.com/users/alice\"\n  :object (Note :content (p \"Hello\") :cid \"bafy...note\")\n  :provenance (Anchor\n    :tree-cid \"bafy...merkle-tree\"\n    :leaf-index 42\n    :ots-cid \"bafy...ots-proof\"\n    :btc-txid \"abc123...def\"\n    :btc-block 890123\n    :anchored-at \"2026-03-06T12:00:00Z\"))" "lisp"))
            (p "Any party can verify: fetch the OTS proof from IPFS, check the Merkle path from the activity's CID to the tree root, confirm the tree root is committed in the Bitcoin block."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "3. Component provenance")
            (p "Components published to the registry also get anchored. This proves authorship and publication time:")
            (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
              (li "\"This component was published by rose-ash.com at block 890123\"")
              (li "Prevents backdating — can't claim you published a component before you actually did")
              (li "License disputes resolvable by checking anchor timestamps")))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "4. Verification UI")
            (p "Client-side provenance badge on federated content:")
            (~docs/code :src (highlight "(defcomp ~plans/sx-activity/provenance-badge (&key anchor)\n  (when anchor\n    (details :class \"inline text-xs text-stone-400\"\n      (summary \"✓ Anchored\")\n      (dl :class \"mt-1 space-y-1\"\n        (dt \"Bitcoin block\") (dd (get anchor \"btc-block\"))\n        (dt \"Timestamp\") (dd (get anchor \"anchored-at\"))\n        (dt \"Proof\") (dd (a :href (str \"ipfs://\" (get anchor \"ots-cid\"))\n                          \"OTS proof\"))))))" "lisp")))))

      (~docs/subsection :title "Verification"
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li "Activity anchored → OTS proof fetchable from IPFS → Merkle path validates → txid confirms in Bitcoin")
          (li "Tampered activity → Merkle proof fails → provenance badge shows ✗")
          (li "Server goes offline → provenance still verifiable (all proofs on IPFS + Bitcoin)"))))

    ;; -----------------------------------------------------------------------
    ;; Phase 6: The Evaluable Web
    ;; -----------------------------------------------------------------------

    (~docs/section :title "Phase 6: The Evaluable Web" :id "phase-6"

      (div (~tw :tokens "rounded border border-violet-200 bg-violet-50 p-4 mb-4")
        (p (~tw :tokens "text-violet-900 font-medium") "What this really is")
        (p (~tw :tokens "text-violet-800") "Not ActivityPub-with-SX. A new web. One where everything — content, components, parsers, renderers, server logic, client logic — is the same executable format, shared on a content-addressed network, running within each participant's own security context."))

      (~docs/subsection :title "The insight"
        (p "The web has six layers that don't talk to each other: HTML (structure), CSS (style), JavaScript (behavior), JSON (data interchange), server frameworks (backend logic), and build tools (compilation). Each has its own syntax, its own semantics, its own ecosystem. Moving data between them requires serialization, deserialization, template languages, API contracts, type coercion, and an endless parade of glue code.")
        (p "SX collapses all six into one evaluable format. A component definition is simultaneously structure, style (components apply classes and respond to data), behavior (event handlers), data (the AST is data), server-renderable (Python evaluator), and client-renderable (JS evaluator). There is no boundary between \"data\" and \"program\" — s-expressions are both.")
        (p "Once that's true, " (strong "everything becomes shareable.") " Not just UI components — markdown parsers, syntax highlighters, date formatters, validation logic, layout algorithms, color systems, animation curves. Any pure function over data. All content-addressed, all on IPFS, all executable within your own security context."))

      (~docs/subsection :title "What travels on the network"
        (div (~tw :tokens "space-y-4")
          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "Content")
            (p "Blog posts, product listings, event descriptions, social media posts. Not HTML strings embedded in JSON — live SX expressions that evaluate to rendered UI. The content " (em "is") " the application."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "Components")
            (p "UI building blocks: cards, tables, forms, navigation, media players. Published to IPFS, referenced by CID. A commerce site publishes " (code "~product-card") ". A blogging platform publishes " (code "~article-layout") ". A social network publishes " (code "~thread-view") ". Anyone can compose them. They're pure functions — safe to load from anywhere."))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "Parsers and transforms")
            (p "A markdown parser is just an SX function: takes a string, returns an SX tree. Publish it to IPFS. Now anyone can use your markdown dialect. Same for: syntax highlighters, BBCode parsers, wiki markup, LaTeX subsets, CSV-to-table converters, JSON-to-SX adapters. " (strong "The parser ecosystem becomes shared infrastructure."))
            (~docs/code :src (highlight ";; A markdown parser, published to IPFS\n;; CID: bafy...md-parser\n(define parse-markdown\n  (fn (source)\n    ;; tokenize → build AST → return SX tree\n    ;; (parse-markdown \"# Hello\\n**bold**\")\n    ;; → (h1 \"Hello\") (p (strong \"bold\"))\n    ...))\n\n;; Anyone can use it in their components\n(defcomp ~plans/sx-activity/blog-post (&key markdown-source)\n  (div :class \"prose\"\n    (parse-markdown markdown-source)))" "lisp")))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "Server-side and client-side logic")
            (p "The same SX code runs on either side. A validation function published to IPFS runs server-side in Python for form processing and client-side in JavaScript for instant feedback. A price calculator runs server-side for order totals and client-side for live previews. " (em "The server/client split is a deployment decision, not a language boundary.")))

          (div
            (h4 (~tw :tokens "font-semibold text-stone-700") "Media and processing pipelines")
            (p "Images, video, audio — all content-addressed on IPFS. But also the " (em "processing pipelines") " that created them. artdag DAGs are SX. Publish a DAG CID alongside the output CID and anyone can verify the provenance, re-render at different resolution, or fork the pipeline for their own work."))))

      (~docs/subsection :title "The security model"
        (p "This only works because of boundary enforcement. Every piece of SX fetched from the network runs within the receiver's security context:")
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li (strong "Pure functions can't do IO. ") "A component from IPFS can produce markup — it cannot read your cookies, make network requests, access localStorage, or call any IO primitive. The boundary spec (boundary.sx) is enforced at registration time. This isn't a policy — it's structural. The evaluator literally doesn't have IO primitives available when running untrusted code.")
          (li (strong "IO requires explicit grant. ") "Only locally-registered IO primitives (query, frag, current-user) have access to server resources. Fetched components never see them. The host decides what capabilities to grant.")
          (li (strong "Step limits cap computation. ") "Untrusted code runs with configurable eval step limits. No infinite loops, no resource exhaustion. Exceeding the limit halts evaluation and returns an error node.")
          (li (strong "Content addressing prevents tampering. ") "You asked for CID X, you got CID X, the hash proves it. No MITM, no CDN poisoning, no supply chain attacks on the content itself.")
          (li (strong "Provenance proves authorship. ") "Bitcoin-anchored timestamps prove who published what and when. Not \"trust me\" — independently verifiable against the Bitcoin blockchain."))
        (p "This is the opposite of the npm model. npm packages run with full access to your system — a malicious package can exfiltrate secrets, install backdoors, modify the filesystem. SX components are structurally sandboxed. The worst a malicious component can do is render a " (code "(div \"haha got you\")") "."))

      (~docs/subsection :title "What this replaces"
        (div (~tw :tokens "overflow-x-auto rounded border border-stone-200 mb-4")
          (table (~tw :tokens "w-full text-left text-sm")
            (thead (tr (~tw :tokens "border-b border-stone-200 bg-stone-100")
              (th (~tw :tokens "px-3 py-2 font-medium text-stone-600") "Current web")
              (th (~tw :tokens "px-3 py-2 font-medium text-stone-600") "SX web")
              (th (~tw :tokens "px-3 py-2 font-medium text-stone-600") "Why")))
            (tbody
              (tr (~tw :tokens "border-b border-stone-100")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "npm / package registries")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "IPFS + component CIDs")
                (td (~tw :tokens "px-3 py-2 text-stone-600") "Content-addressed, no central authority, structurally safe"))
              (tr (~tw :tokens "border-b border-stone-100")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "CDNs for JS/CSS")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "IPFS gateways")
                (td (~tw :tokens "px-3 py-2 text-stone-600") "Permanent, decentralized, self-verifying"))
              (tr (~tw :tokens "border-b border-stone-100")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "REST/GraphQL APIs")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "SX activities over AP")
                (td (~tw :tokens "px-3 py-2 text-stone-600") "Responses are evaluable, not just data"))
              (tr (~tw :tokens "border-b border-stone-100")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "HTML + CSS + JS")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "SX (one format)")
                (td (~tw :tokens "px-3 py-2 text-stone-600") "No impedance mismatch, same evaluator everywhere"))
              (tr (~tw :tokens "border-b border-stone-100")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "Build tools (webpack, vite)")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "Nothing")
                (td (~tw :tokens "px-3 py-2 text-stone-600") "SX evaluates directly, no compilation step"))
              (tr (~tw :tokens "border-b border-stone-100")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "Template languages")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "Nothing")
                (td (~tw :tokens "px-3 py-2 text-stone-600") "SX is the template and the language"))
              (tr (~tw :tokens "border-b border-stone-100")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "JSON-LD federation")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "SX federation")
                (td (~tw :tokens "px-3 py-2 text-stone-600") "Wire format is executable, content renders itself"))
              (tr (~tw :tokens "border-b border-stone-100")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "Trust-based package security")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "Structural sandboxing")
                (td (~tw :tokens "px-3 py-2 text-stone-600") "Pure functions can't have side effects — not by policy, by construction"))
              (tr (~tw :tokens "border-b border-stone-100")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "Servers + hosting + DNS + TLS")
                (td (~tw :tokens "px-3 py-2 text-stone-700") "IPFS CID")
                (td (~tw :tokens "px-3 py-2 text-stone-600") "Entire applications are content-addressed, no infrastructure needed"))))))

      (~docs/subsection :title "Serverless applications on IPFS"
        (p "The logical conclusion: " (strong "entire web applications hosted on IPFS with no server at all."))
        (p "An SX application is a tree of content-addressed artifacts: a root page definition, component dependencies, media, stylesheets, parsers, transforms. Pin the root CID to IPFS and the application is live. No server, no DNS, no hosting provider, no deployment pipeline. Someone gives you a CID, you paste it into an SX-aware browser, and the application runs.")
        (~docs/code :src (highlight ";; An entire blog — one CID\n;; ipfs://bafy...my-blog\n(defpage blog-home\n  :path \"/\"\n  :requires (list\n    \"bafy...article-layout\"    ;; layout component\n    \"bafy...md-parser\"         ;; markdown parser\n    \"bafy...syntax-highlight\"  ;; code highlighting\n    \"bafy...nav-component\")    ;; navigation\n  :content\n    (~article-layout\n      :title \"My Blog\"\n      :nav (~nav-component\n        :items (list\n          (dict :label \"Post 1\" :cid \"bafy...post-1\")\n          (dict :label \"Post 2\" :cid \"bafy...post-2\")))\n      :body (~markdown-page\n        :source-cid \"bafy...homepage-md\")))" "lisp"))
        (p "What this looks like in practice:")
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li (strong "Personal sites: ") "A portfolio or blog is a handful of SX files + media. Pin to IPFS. Share the CID. No hosting costs, no domain renewal, no SSL certificates. The site is permanent.")
          (li (strong "Documentation: ") "Pin your docs. They can't go offline, can't be censored, can't be altered after publication (provenance proves it). Anyone can mirror them by pinning the same CID.")
          (li (strong "Collaborative applications: ") "Multiple authors contribute pages and components. Each publishes their CIDs. A root manifest composes them. Update the manifest CID to add content — old CIDs remain valid forever.")
          (li (strong "Offline-first: ") "An IPFS-hosted app works the same whether you're online or have the content cached locally. The browser's SX evaluator + local IPFS node = complete offline platform.")
          (li (strong "Zero-cost deployment: ") "\"Deploying\" means computing a hash. No CI/CD, no Docker, no cloud provider. Pin locally, pin to a remote IPFS node, or let others pin if they want to help host."))
        (p "For applications that " (em "do") " need a server — user accounts, payments, real-time collaboration, database queries — the server provides IO primitives via the existing boundary system. The SX application fetches data from the server's IO endpoints, but the application itself (all the rendering, routing, component logic) lives on IPFS. The server is a " (em "data service") ", not an application host.")
        (p "This inverts the current model. Today: server hosts the application, client is a thin renderer. SX web: IPFS hosts the application, server is an optional IO provider. " (strong "The application is the content. The content is the application. Both are just s-expressions.")))

      (~docs/subsection :title "The end state"
        (p "A browser with an SX evaluator and an IPFS gateway is a complete web platform. Given a CID — for a page, a post, an application — it can:")
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li "Fetch the content from IPFS")
          (li "Resolve component dependencies (also from IPFS)")
          (li "Resolve media (also from IPFS)")
          (li "Evaluate the content (pure computation, sandboxed)")
          (li "Render to DOM")
          (li "Verify provenance (Bitcoin anchor)")
          (li "Cache everything forever (content-addressed = immutable)"))
        (p "No server needed. No DNS. No TLS certificates. No hosting provider. No build step. No framework. Just content-addressed s-expressions evaluating in a sandbox.")
        (p "The server becomes optional infrastructure for " (em "IO") " — database queries, authentication, payment processing, real-time events. Everything else lives on the content-addressed network. The web stops being a collection of servers you visit and becomes a " (strong "shared evaluable space") " you participate in.")))

    ;; -----------------------------------------------------------------------
    ;; Cross-Cutting Concerns
    ;; -----------------------------------------------------------------------

    (~docs/section :title "Cross-Cutting Concerns" :id "cross-cutting"

      (~docs/subsection :title "Security"
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li (strong "Boundary enforcement is the foundation. ") "IPFS-fetched components are parsed and registered like any other component. SX_BOUNDARY_STRICT ensures they can't call IO primitives. A malicious component can produce ugly markup but can't exfiltrate data or make network requests.")
          (li (strong "CID verification: ") "Content fetched from IPFS is hashed and compared to the expected CID before use. Tampered content is rejected.")
          (li (strong "Signature chain: ") "Actor signatures (RSA/HTTP Signatures) prove authorship. Bitcoin anchors prove timing. Together they establish non-repudiable provenance.")
          (li (strong "Resource limits: ") "Evaluation of untrusted components runs with step limits (max eval steps, max recursion depth). Infinite loops are caught and terminated.")))

      (~docs/subsection :title "Backward Compatibility"
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li "Content negotiation ensures legacy AP servers always receive valid JSON-LD")
          (li "SX-Activity is strictly opt-in — servers that don't understand it get standard AP")
          (li "Existing internal activity bus unchanged — SX format is for federation, not internal events")
          (li "URL fallbacks on all media references — CID is preferred, URL is fallback")))

      (~docs/subsection :title "Performance"
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li "Component CIDs cached in localStorage forever (content-addressed = immutable)")
          (li "IPFS gateway responses cached with long TTL (content can't change)")
          (li "Local IPFS node (if present) eliminates gateway latency")
          (li "Provenance verification is lazy — badge shows unverified until user clicks to verify")))

      (~docs/subsection :title "Integration with Isomorphic Architecture"
        (p "SX-Activity builds on the isomorphic architecture plan:")
        (ul (~tw :tokens "list-disc pl-5 text-stone-700 space-y-1")
          (li "Phase 1 (component distribution) → IPFS replaces per-server bundles")
          (li "Phase 2 (IO detection) → pure components safe for IPFS publication")
          (li "Phase 3 (client routing) → client can resolve federated content without server")
          (li "Phase 6 (streaming/suspense) → progressive IPFS resolution uses same infrastructure"))))

    ;; -----------------------------------------------------------------------
    ;; Critical Files
    ;; -----------------------------------------------------------------------

    (~docs/section :title "Critical Files" :id "critical-files"
      (div (~tw :tokens "overflow-x-auto rounded border border-stone-200")
        (table (~tw :tokens "w-full text-left text-sm")
          (thead (tr (~tw :tokens "border-b border-stone-200 bg-stone-100")
            (th (~tw :tokens "px-3 py-2 font-medium text-stone-600") "File")
            (th (~tw :tokens "px-3 py-2 font-medium text-stone-600") "Role")
            (th (~tw :tokens "px-3 py-2 font-medium text-stone-600") "Phases")))
          (tbody
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/infrastructure/activitypub.py")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "AP blueprint — add SX content negotiation")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "1"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/events/bus.py")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "Activity bus — add sx_source column, SX serialization")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "1"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/sx/activity.py")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "SX ↔ JSON-LD bidirectional translation (new)")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "1"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/sx/ipfs.py")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "Component CID computation, IPFS pinning (new)")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "2, 3"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/sx/ref/ipfs-resolve.sx")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "Client-side IPFS resolution spec (new)")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "2, 3"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/models/federation.py")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "IPFSPin, APAnchor models — extend for components")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "2, 3, 5"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/sx/registry.py")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "Component registry actor, discovery protocol (new)")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "4"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/sx/anchor.py")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "Anchoring pipeline — wire to activity lifecycle (new)")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "5"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/sx/ref/boot.sx")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "Client boot — IPFS component loading")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "2, 6"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "shared/events/handlers/ap_delivery_handler.py")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "Federation delivery — SX format support")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "1"))
            (tr (~tw :tokens "border-b border-stone-100")
              (td (~tw :tokens "px-3 py-2 font-mono text-sm text-violet-700") "artdag/core/artdag/cache.py")
              (td (~tw :tokens "px-3 py-2 text-stone-700") "Content addressing — shared with component CIDs")
              (td (~tw :tokens "px-3 py-2 text-stone-600") "2, 3"))))))))

;; ---------------------------------------------------------------------------
;; Content-Addressed Components
;; ---------------------------------------------------------------------------
