tricu

main.tri (4446B)

---

 !import prelude *
 !import io *
 !import consumers_module as M
 !import consumers_link as CL
 !import consumers_text_summary as T
 !import source_resolve as Resolve
 !export *
 -- From the repository root, after `nix build .#`:
 --   result/bin/tricu eval demos/consumers/source-linked-summary/main.tri \
 --     --store "$(mktemp -d)" --unsafe-io --io --format tree
 -- Expect `lines: 4` from sample.txt (fourth line has no trailing newline).
 -- The bootstrap IO command prints a final `t` after the application output.
 -- Focused fresh-store check: bash test/consumer_source_link_demo.sh result/bin/tricu
 --
 -- countLines.scp counts records with compact naturals using succ.scp;
 -- entry.scp requests named ReadText and keeps its worker; receiver.scp
 -- handles success/failure and calls the counter only on success. The four
 -- authored sources are copied from the separately tested library/client.
 -- This entrypoint stages their exact source bytes, pins their digests in a
 -- tricu-owned CAS import descriptor, resolves verified objects, publishes and
 -- reloads original IR sidecars, then compiles successor and three client workers.
 -- The effect driver owns file IO. No Python embeds the sources or interprets
 -- them. The printed hashes identify the import descriptor and IR manifest,
 -- not an attestation or a packed worker artifact. `run path` accepts another
 -- file; inputFile selects the direct-entrypoint sample.
 
 -- This explicit source CAS root is separate from the bootstrap `--store`
 -- module-import store. A changed source makes a new pinned descriptor;
 -- previously pinned descriptors keep identifying their original source bytes.
 sourceStore = "/tmp/tricu-scp-summary-demo.v1"
 sourceDirectory = "demos/consumers/source-linked-summary/"
 inputFile = "demos/consumers/source-linked-summary/sample.txt"
 importRow alias hash name = pair alias (pair hash name)
 
 -- Filesystem access is limited to initial source staging and the explicit
 -- ReadText application effect. cmLoad below resolves exclusively from CAS.
 stage = do onOk_
   succSource <- readFile (append sourceDirectory "succ.scp")
   succHash <- M.cmPutSource sourceStore succSource
   countSource <- readFile (append sourceDirectory "countLines.scp")
   countHash <- M.cmPutSource sourceStore countSource
   entrySource <- readFile (append sourceDirectory "entry.scp")
   entryHash <- M.cmPutSource sourceStore entrySource
   receiverSource <- readFile (append sourceDirectory "receiver.scp")
   receiverHash <- M.cmPutSource sourceStore receiverSource
   M.cmPutImports sourceStore [
     (importRow "successor" succHash "succBinary")
     (importRow "counter" countHash "countLines")
     (importRow "entry" entryHash "summaryEntry")
     (importRow "receiver" receiverHash "summaryReceiver")]
 
 -- Compile the verified successor first, then inject its executable descriptor
 -- into the counter's initial state. Both rounds resolve the same pinned source
 -- descriptor; the initial worker graph is explicit application policy.
 prepare descriptor = (onResult_
   (CL.clPrepare sourceStore descriptor [(pair "successor" t)])
   (problem : pure (err problem t))
   (prepared : lazyMaybe
     (_ : pure (err "missing successor" t))
     (successor : CL.clPrepare sourceStore descriptor [
       (pair "counter" (T.counterState successor))
       (pair "entry" t)
       (pair "receiver" t)])
     (Resolve.sourceFindExternal (fst (snd prepared)) "successor")))
 lookupWorker workers alias =
   (lazyMaybe (_ : err (append "missing worker: " alias) t)
     (worker : ok worker t) (Resolve.sourceFindExternal workers alias))
 selectWorkers workers = (bindResult (lookupWorker workers "counter") (counter _ :
   bindResult (lookupWorker workers "entry") (entry _ :
     bindResult (lookupWorker workers "receiver") (receiver _ :
       ok (pair counter (pair entry receiver)) t))))
 
 run path = (onOk_ stage (descriptor : onOk_ (prepare descriptor) (prepared :
   lazyResult
     (problem _ : pure (err problem t))
     (selected _ : bind (T.summaryLexical (fst selected)
       (fst (snd selected)) (snd (snd selected)) path)
       (outcome : pure (ok (pair descriptor (pair (fst prepared) outcome)) t)))
     (selectWorkers (fst (snd prepared))))))
 main = io (onResult_ (run inputFile)
   (problem : putStrLn "source-linked summary failed")
   (report : do bind
     _ <- putStrLn (append "imports=" (fst report))
     _ <- putStrLn (append "sidecars=" (fst (snd report)))
     putStrLn (T.render (snd (snd report)))))