Support multiple named exports globally

Add multi-root bundle support across the toolchain:
 - `compile`: Accept multiple definition names via `-x NAME` (repeatable or
   comma-separated). Exports all requested definitions as named roots in a
   single bundle. Defaults to "main" when no names are given.
 - `export`: Accept comma-separated hashes in the positional argument and
   multiple `-n`/`names` flags. Exports all resolved roots in one bundle.
 - Server: Add `GET /bundle/roots?n=...&h=...` endpoint that resolves
   multiple stored-term names and/or raw Merkle hashes, returning a single
   bundle containing all of them as roots.
 - Wire: Export `defaultExportNames` helper for generating default export
   names when none are supplied.
 - Drop `cereal` dependency from `tricu.cabal` (no longer used).

src/Server.hs

@@ -7,16 +7,20 @@ import ContentStore (initContentStore, nameToTerm, hashToTerm, listStoredTerms,
 import Database.SQLite.Simple (close)
 import Wire (exportNamedBundle)
 
+import Control.Monad (when)
+import Data.Maybe (catMaybes)
+import Control.Monad (void)
+
 import Network.HTTP.Types (Header, Status, status200, status400, status404, status405, hContentType)
 import Network.Wai
 import Network.Wai.Handler.Warp (defaultSettings, runSettings, setHost, setPort)
 
 import Data.String (fromString)
 import Data.Text (Text)
-import Data.Text.Encoding (encodeUtf8)
-import Data.Char (isHexDigit)
+import Data.Text.Encoding (encodeUtf8, decodeUtf8)
+import Data.Char (isHexDigit, toLower)
+import Data.ByteString.Char8 (unpack)
 import Data.ByteString.Lazy (fromStrict)
-
 import qualified Data.Text as T
 
 -- | Start an HTTP server that serves Arborix bundles from the
@@ -30,10 +34,11 @@ import qualified Data.Text as T
 --
 -- Endpoints
 -- ---------
---   GET /health                   - 200 "ok"
---   GET /bundle/name/:name        - export by stored term name
---   GET /bundle/hash/:hash        - export by full Merkle hash
---   GET /terms                    - plain-text listing (debug)
+--   GET /health                           - 200 "ok"
+--   GET /bundle/name/:name                - export single term by name
+--   GET /bundle/hash/:hash                - export single term by hash
+--   GET /bundle/roots?n=...&h=...         - export multiple roots (n=name, h=hash)
+--   GET /terms                            - plain-text listing (debug)
 --
 runServer :: String -> Int -> IO ()
 runServer hostStr port =
@@ -49,6 +54,9 @@ app request respond = case (requestMethod request, pathInfo request) of
   ("GET", ["health"]) ->
     respond $ healthResponse
 
+  ("GET", ["bundle", "roots"]) ->
+    rootsHandler request respond
+
   ("GET", ["bundle", "name", nameText]) -> do
     body <- nameHandler nameText
     respond body
@@ -76,6 +84,54 @@ app request respond = case (requestMethod request, pathInfo request) of
 healthResponse :: Response
 healthResponse = responseLBS status200 [] "ok"
 
+-- | GET /bundle/roots?n=root&n=helper&h=abc123...
+--   Resolve multiple named roots (by stored term name or raw hash)
+--   and return a single bundle containing all of them.
+--
+--   Query parameters:
+--     - @n=<name>@ — one or more stored term names (resolved via nameToTerm)
+--     - @h=<hash>@ — one or more full Merkle hashes (validated as 16-64 hex chars)
+--
+--   The bundle manifest receives all resolved (name, hash) pairs as roots
+--   and exports. The node section is the union of all reachable nodes.
+rootsHandler :: Request -> (Response -> IO a) -> IO a
+rootsHandler request respond = do
+  conn <- initContentStore
+  let qs = queryString request
+      nParams = catMaybes [v | (k, v) <- qs, map toLower (unpack k) == "n"]
+      hParams = catMaybes [v | (k, v) <- qs, map toLower (unpack k) == "h"]
+  -- Resolve 'n' params to (name, hash) pairs
+  nResults <- mapM (\nVal -> do
+    stored <- nameToTerm conn (decodeUtf8 nVal)
+    case stored of
+      Nothing -> return Nothing
+      Just t  -> return $ Just (decodeUtf8 nVal, termHash t)) nParams
+  let namedHashesFromN = catMaybes nResults
+  -- Validate 'h' params and build (name, hash) pairs
+  namedHashesFromH <- mapM (\hVal -> do
+    let raw = T.pack (dropWhile (=='#') (T.unpack (decodeUtf8 hVal)))
+    if T.all isHexDigit raw && T.length raw >= 16
+      then do
+        stored <- hashToTerm conn raw
+        let names = maybe "root" firstOrRoot (termNames <$> stored)
+        return $ Just (names, raw)
+      else return Nothing)
+    hParams
+  let allNamedHashes = namedHashesFromN ++ catMaybes namedHashesFromH
+  -- Require at least one root
+  when (null allNamedHashes) $ do
+    let resp = responseLBS status400 [] "400 Bad Request: at least one n= or h= parameter required"
+    close conn
+    void $ respond resp
+  -- Build and return the bundle
+  bundleData <- exportNamedBundle conn allNamedHashes
+  let firstHash = snd (head allNamedHashes)
+      cd = T.pack "attachment; filename=roots.bundle"
+  close conn
+  respond $ responseLBS status200
+    (bundleHeaders firstHash cd)
+    (fromStrict bundleData)
+
 -- | GET /bundle/name/:name
 --   Resolve a stored term name, export it as an Arborix bundle,
 --   and return the raw bundle bytes.