Packs

Taking one

nestera packs <name> --into ./mine leaves a directory you can run and then change: the sources as well as the compiled graphs, and a pack.lock naming the exact bytes you took.

That lock is the difference between a copy and this copy. A hash names one immutable sequence of bytes for all time, so a pack pinned to those hashes is pinned to behaviour rather than to a name somebody else controls — nothing upstream can change what you installed, and you choose when to take a newer one.

People and groups talking, with things attached

A conversation is a channel pile. A group is one whose roles admit its members; an individual is a message addressed to one person's agent record; a photo is a hash in the record and bytes in a bucket named by that hash. The database behind it is five piles: people, groups, membership, and a pile per room.

Almost none of it is chat-specific. No permission system was bolted on, because the one that stops an agent writing outside its lease already answers who can see a room. Membership records are a directory, not a gate: when they and the roles disagree, the roles win, because a record cannot decide who may read a pile.

• graph chat.ng
• graph groups.ng
• uses build run serve story
• needs a bucket directory for anything larger than a record
• needs house.ncfg, which is the database: piles, forms and who may act
• run sh packs/chat/demo.sh
• take it nestera packs chat --into ./mine

An agreement between two parties

A contract published as a graph, fetched and checked by the other side, signed independently by both with neither going first, proved to be the same terms, run with a person's approval, and replayed byte-for-byte from its own ledger.

The clauses and the code are the same bytes. Everywhere else a contract has a prose version and an implementation, and the gap between them is where the arguments live.

• graph terms.ng
• uses build serve browse agree run story replay
• needs a key for each party
• run sh packs/contract/demo.sh
• take it nestera packs contract --into ./mine

Share a set of files, from wherever they happen to live

The bytes go into buckets addressed by their own hash; the list is a small signed text file. Handing someone a drop is handing them the list, and they fetch the bytes from whatever source still answers.

The list names content, never a location. So the same drop works off a desktop that is only on sometimes, a web host, a mirror or a stranger -- and a file that arrives wrong is refused rather than written, which is what makes an untrusted source safe.

• uses serve drop
• needs a cell with a bucket directory, or several
• run sh packs/dropbox/demo.sh
• take it nestera packs dropbox --into ./mine

Quote to payment, with the chase

A quote approved by a person becomes an invoice numbered from a counter cell, payment is recorded in minor units, and a scheduled sweep finds what is overdue and composes a reminder.

It is the scenario the conformance suite pins (S02), so the pack a customer receives is the same graph the goldens are taken from.

• graph invoicing.ng
• uses build check run story statement replay
• needs a connector for the reminder to leave the house
• take it nestera packs invoicing --into ./mine

Two houses talking through one table

A thin HTTP endpoint over MySQL that two cells post to and poll. What arrives is filed as a record of what was said; acting on it is the receiving house's own decision under its own rules.

A connector speaks HTTP and nothing else, deliberately: a database driver inside the host is a much larger thing to trust than a request, and every port would have to trust it too.

• graph shared.ng
• uses build run
• needs PHP and MySQL on shared hosting, and a shared key
• take it nestera packs shared --into ./mine