@nervur.org/genome 0.37.8 → 0.37.9
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +22 -21
- package/docs/authoring.md +26 -22
- package/docs/changelog.md +5 -6
- package/docs/guide.md +437 -323
- package/genome/brain/guide.js +2 -2
- package/genome/faculties/ear/blueprint.js +1 -1
- package/genome/faculties/ear/text.js +1 -1
- package/genome/faculties/library/blueprint.js +1 -1
- package/genome/faculties/library/text.js +1 -1
- package/genome/faculties/mouth/blueprint.js +1 -1
- package/genome/faculties/mouth/text.js +1 -1
- package/genome/faculties/scheduler/blueprint.js +1 -1
- package/genome/faculties/scheduler/text.js +1 -1
- package/package.json +1 -1
- package/standard/version.js +1 -1
package/docs/guide.md
CHANGED
|
@@ -1,409 +1,482 @@
|
|
|
1
1
|
# Nervur's guide
|
|
2
2
|
|
|
3
|
-
What Nervur is and how an organism works,
|
|
4
|
-
|
|
5
|
-
organism
|
|
6
|
-
|
|
7
|
-
`authoring
|
|
8
|
-
|
|
9
|
-
|
|
3
|
+
What Nervur is and how an organism works, in a few pages: the model to hold before touching anything, whether you are a
|
|
4
|
+
person, a model at an organism's console, or someone building on Nervur. The brain carries this guide, so a model
|
|
5
|
+
present at an organism can read it first. Beside it, in the genome's `docs/`:
|
|
6
|
+
|
|
7
|
+
- `authoring.md` says how to install, own and build on Nervur, each path with its commands and code; the brain answers
|
|
8
|
+
it as `authoring`.
|
|
9
|
+
- `changelog.md` says what each version changed, from 0.37.1, the first published.
|
|
10
|
+
|
|
11
|
+
The exact detail of a node is in what it answers a **describe**, an ask that names no method: what it may be asked. A
|
|
12
|
+
faculty's own guide, in its blueprint, says how it is run and used. The words this guide defines are listed at its end.
|
|
10
13
|
|
|
11
14
|
## The bet
|
|
12
15
|
|
|
13
|
-
Software as a graph, never accounts. Every person, group and agent is an **organism**
|
|
14
|
-
organisms ask each other over **Quo**,
|
|
15
|
-
|
|
16
|
-
that already exist, never by one
|
|
16
|
+
Software as a graph of beings, never as accounts on someone's server. Every person, group and agent is an **organism**
|
|
17
|
+
on a device of its own, and organisms ask each other over **Quo**, Nervur's protocol between organisms, never through
|
|
18
|
+
a server they share. A shop keeps what it knows of its customer in its own organism; the person keeps the rest in their
|
|
19
|
+
home, their own organism. Nervur grows by being many small organisms on devices that already exist, never by one
|
|
20
|
+
growing big.
|
|
21
|
+
|
|
22
|
+
What is scarce is trust, not code. A shape is worth what it makes certain: who may ask whom, what ran, and what it
|
|
23
|
+
changed. So the parts are few: the organism, the relation between two of them, the ask, the letter and the owner.
|
|
17
24
|
|
|
18
|
-
|
|
19
|
-
|
|
25
|
+
The **genome**, Nervur's kernel, is to an organism what Linux is to a machine: small, slow to change, built for
|
|
26
|
+
decades, with no opinion of what is built on it. **The owner is root.** Code starts with nothing, and an owner can give
|
|
27
|
+
it everything: code gains power by the wires and organs an owner gives it, never by escaping the cage it runs in.
|
|
20
28
|
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
limits, and build powerful things on Nervur: what people do with it is theirs.
|
|
29
|
+
A limit in Nervur is one of two kinds. A **wall** stands only where it protects someone other than the owner, or where a
|
|
30
|
+
promise could not be proven without it: code that runs pure, memory each piece of code keeps closed, keys never handed
|
|
31
|
+
over, an ask that ends exactly once. Every other limit is a **default**, which an owner can change; a limit no owner can
|
|
32
|
+
move that is not a wall is a fault in Nervur. So of any limit, ask whom it limits. Build powerful things: what people do
|
|
33
|
+
with Nervur is theirs.
|
|
27
34
|
|
|
28
35
|
## The organism
|
|
29
36
|
|
|
30
|
-
An organism lives on one **device**,
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
37
|
+
An organism lives on one **device**, in an account of its own there: an account of an operating system, one site in a
|
|
38
|
+
browser, a phone's app, or an edge's durable object. It is sealed, with two doors and no third:
|
|
39
|
+
|
|
40
|
+
- **The ear**, where every other being enters, over Quo.
|
|
41
|
+
- **The door**, where the device reaches it through its installer: install, boot, update, wipe.
|
|
42
|
+
|
|
43
|
+
Everything else that touches the world or the host is an **organ**, a driver.
|
|
34
44
|
|
|
35
|
-
A device gives
|
|
45
|
+
A device gives an organism two **zones**:
|
|
36
46
|
|
|
37
|
-
- **The self
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
relation, where a rewrap moves the boot key alone. Who an organism is stands apart from where it is: an owner names
|
|
45
|
-
the addresses it is reached at, ahead of a move.
|
|
47
|
+
- **The self** is the organism's own account. It holds `key` (the boot key, which opens everything else), `store` (the
|
|
48
|
+
organism's memory, encrypted), `cage` (which runs code and keeps time) and presence (the console and the screen). The
|
|
49
|
+
self keeps what it holds.
|
|
50
|
+
- **The body** is a second account, for work: `shell` runs programs, `disk` keeps files, `network` reaches the world,
|
|
51
|
+
and each organ built from a repo runs there. The self starts programs as the body, never the other way round, so
|
|
52
|
+
nothing the body runs can read the key or the memory. The body forgets: a backup carries the self alone, and what the
|
|
53
|
+
body held is fetched again from the world.
|
|
46
54
|
|
|
47
55
|
A host has a body where it has `shell` and `disk`. A server, a desktop, a Pi and a NAS have one; a browser, a phone's
|
|
48
56
|
app and an edge do not.
|
|
49
57
|
|
|
58
|
+
An organism's life can change place without changing who it is:
|
|
59
|
+
|
|
60
|
+
- **A backup** is an older life. Restored, the organism wakes as it was then, and each lobe is told so first.
|
|
61
|
+
- **A salvage** reads what a damaged store still opens, at the door, without booting it.
|
|
62
|
+
- **A move** carries the organism, sealed to one target device, to be the same life there; the copy it left stops.
|
|
63
|
+
- **A rekey** is a move onto itself: a new key for its memory that costs no relation. A **rewrap** changes only the
|
|
64
|
+
boot key that guards it.
|
|
65
|
+
|
|
66
|
+
Who an organism is stands apart from where it is reached: an owner names the addresses it answers at, ahead of a move.
|
|
67
|
+
|
|
50
68
|
## Nodes and the graph
|
|
51
69
|
|
|
52
|
-
Everything in an organism is a **node**, under an ID, with one **termination
|
|
70
|
+
Everything in an organism is a **node**, under an ID, with one **termination**, the single place every ask to it
|
|
71
|
+
arrives. A node is one of three kinds:
|
|
53
72
|
|
|
54
|
-
- **An organ
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
- **A lobe
|
|
58
|
-
its **cells**, its own
|
|
59
|
-
|
|
73
|
+
- **An organ**, a driver. Its graph half is its **blueprint**, what it declares of itself (its name, its version, its
|
|
74
|
+
methods), and its **reach**, what of its host it may touch; the brain holds both. Its **host half** is code running
|
|
75
|
+
on the device. An organ holds no cells and declares no placeholders.
|
|
76
|
+
- **A lobe**, one instance of a **faculty**, which is pure code. A lobe lives only while it answers an ask, and keeps
|
|
77
|
+
nothing between asks but its **cells**, its own private part of the organism's memory. It keeps its ID, its wires,
|
|
78
|
+
its relations and its cells across new versions of its faculty.
|
|
79
|
+
- **A far organism**, which stands in the graph for one relation over Quo, in one direction, and nothing more.
|
|
60
80
|
|
|
61
81
|
The **core** is there from the first install and never torn down: the organs `key`, `store`, `cage` and `network`, and
|
|
62
82
|
the lobes `brain`, `scheduler`, `ear`, `mouth` and `library`. Everything else is **periphery**.
|
|
63
83
|
|
|
64
|
-
Nodes meet only through **wires**. A node declares **placeholders**,
|
|
65
|
-
termination, one way. The **brain** alone writes wiring and checks only that the
|
|
66
|
-
the
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
84
|
+
Nodes meet only through **wires**. A node declares **placeholders**, the things it needs, each by name; a wire joins one
|
|
85
|
+
placeholder to one termination, one way. The **brain** alone writes the wiring, and checks only that the node a
|
|
86
|
+
placeholder receives has the blueprint name it expects. A wire says who reaches whom, and code reaches only what its
|
|
87
|
+
wires give it. Declaring a placeholder wires nothing: a new lobe starts with two wires, its `cells` and its `nerves`
|
|
88
|
+
(its own handle on its wiring), and every other wire is named when it is created or ordered later. What stands unwired
|
|
89
|
+
an owner sees in the brain's `state`.
|
|
90
|
+
|
|
91
|
+
Connection comes only from connection. A lobe orders wires through its `nerves`, and only for its own children and for
|
|
92
|
+
whoever asked it; every other wire is an owner's word, given through the brain, and an owner can wire a lobe to the
|
|
93
|
+
brain to give it that power. A lobe may raise **children**; a child reaches nothing its parent does not, so power only
|
|
73
94
|
narrows down the line.
|
|
74
95
|
|
|
96
|
+
A lobe that declares a placeholder named after an organ is that organ's **skin lobe**: the only way an organ meets the
|
|
97
|
+
rest of the graph.
|
|
98
|
+
|
|
75
99
|
## The ask
|
|
76
100
|
|
|
77
|
-
Nodes meet only through the **ask**: a method, its
|
|
78
|
-
every ask and stamps it with
|
|
79
|
-
once, with `{result}` or `{error: {code, message}}`.
|
|
101
|
+
Nodes meet only through the **ask**: a method, its arguments (plain data) and a timeout, sent over a placeholder. The
|
|
102
|
+
brain carries every ask and stamps it with who asked, the time, a fresh 32-byte random seed and the lobe's memory.
|
|
103
|
+
Every ask ends exactly once, with `{result}` or with `{error: {code, message}}`.
|
|
80
104
|
|
|
81
|
-
- **Whole or nothing.** A lobe's writes take effect in one batch when it answers. If the brain answers in
|
|
82
|
-
(timeout, fault, busy), nothing it wrote remains. An answer reaches its asker only once its batch
|
|
83
|
-
answer always means it happened. What a lobe already sent to the world stays sent.
|
|
84
|
-
- **From far.** Only
|
|
85
|
-
came may
|
|
86
|
-
run again. An ask that must not run twice carries a key of its asker's.
|
|
105
|
+
- **Whole or nothing.** A lobe's writes take effect together, in one batch, when it answers. If the brain answers in
|
|
106
|
+
its place (a timeout, a fault, too busy), nothing it wrote remains. An answer reaches its asker only once its batch
|
|
107
|
+
is on disk, so an answer always means it happened. What a lobe already sent out to the world stays sent.
|
|
108
|
+
- **From far.** Only the far side's own answer says what happened there. Any other ending may still have run, and
|
|
109
|
+
where no reply came it may run until the next ask on that relation is answered. The error `repeated` means the far
|
|
110
|
+
door already took that ask, so it will not run again. An ask that must not run twice carries a key of its asker's.
|
|
87
111
|
- **Reading and writing.** A reading method writes nothing and runs beside others; a writing method runs alone.
|
|
88
|
-
- **Signal or letter.** A **signal** lives in memory and is lost in a crash. A **letter** is kept in
|
|
89
|
-
until
|
|
90
|
-
- **Durable asks** go to organs: the brain sends them again
|
|
91
|
-
- **Time.** A **budget** bounds the real time a run
|
|
92
|
-
either the run is cut, nothing it wrote lands, and the asker hears `timeout`.
|
|
93
|
-
answer is worth
|
|
94
|
-
that must pause, before a retry or while it holds its lobe, asks its `nerves` `wait {ms}`,
|
|
95
|
-
span has passed, or `timeout`
|
|
96
|
-
|
|
97
|
-
asker
|
|
98
|
-
judged by progress, never by one slow piece.
|
|
99
|
-
- **Queues.**
|
|
100
|
-
share alone
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
wired to it.
|
|
112
|
+
- **Signal or letter.** A **signal** lives in memory and is lost in a crash. A **letter** is kept in the organism's
|
|
113
|
+
memory until its lobe takes it, exactly once. An ask whose loss matters is a letter.
|
|
114
|
+
- **Durable asks** go to organs: the brain sends them again each time the organ reconnects, as "keep listening".
|
|
115
|
+
- **Time.** A **budget** bounds the real time a run may work, watched from outside it; a **timeout** bounds how long an
|
|
116
|
+
asker waits. Past either, the run is cut, nothing it wrote lands, and the asker hears `timeout`. Name a timeout only
|
|
117
|
+
where an answer is worth nothing after it; otherwise an ask waits as long as it may, and an inner ask never outlives
|
|
118
|
+
the outer one. A run that must pause, before a retry or while it holds its lobe, asks its `nerves` `wait {ms}`, which
|
|
119
|
+
answers `null` once the span has passed, or `timeout` if its own ask's time ends first; waiting spends no budget.
|
|
120
|
+
- **Long work** answers at once and finishes later, either by asking back or as a **job**: a node that cannot ask its
|
|
121
|
+
asker back answers a job at once, and the asker hands it back to ask how the work ended. Long work is cut into pieces
|
|
122
|
+
and judged by progress, never by one slow piece.
|
|
123
|
+
- **Queues.** Each lobe has one queue, and asks start in the order they arrive. Each asker holds a share of it, and an
|
|
124
|
+
asker past its share alone hears `busy`.
|
|
125
|
+
- **No circle of waiting.** An ask that could only start once a run ends that is itself waiting on it, through any
|
|
126
|
+
number of lobes, queues or the brain, is answered `refused` at once instead of waiting forever. The same holds for a
|
|
127
|
+
move of a lobe's version, which waits for that lobe's runs. A run racing two asks is never refused for the one it may
|
|
128
|
+
not need; one waiting on both hears the circling one refused the moment the other answers. A reading ask that starts
|
|
129
|
+
beside other readers waits on none of them. Between organisms nothing can see such a circle, so it ends at its
|
|
130
|
+
timeouts.
|
|
131
|
+
- **Status.** Every termination is not ready, connected, unavailable or far, and its status flows into each
|
|
132
|
+
placeholder wired to it.
|
|
110
133
|
|
|
111
134
|
## Ownership
|
|
112
135
|
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
136
|
+
The brain has no roles. Whoever may ask the brain is an **owner**:
|
|
137
|
+
|
|
138
|
+
- whoever is **present** at the device, at the console or at the screen the configuration names present;
|
|
139
|
+
- whoever holds, from afar, a relation the brain itself gave out;
|
|
140
|
+
- a lobe an owner wired to the brain, holding what that owner gave it.
|
|
141
|
+
|
|
142
|
+
Every other being reaches only the lobe that invited it. A relation to the brain is ownership; a relation to a lobe is
|
|
143
|
+
belonging, buying, following, whatever that lobe makes it. Roles live in lobes.
|
|
144
|
+
|
|
145
|
+
- **Presence wins over the graph, never over the account.** The present lobes, the console's and the screen's, are one
|
|
146
|
+
person and hold their relations alike.
|
|
147
|
+
- **A model at the console** is present as a person is, holds no more, and never changes the skins of presence. It
|
|
148
|
+
reaches the organism by `nervur mcp`, the console as an MCP server: a tool for each method of each node the console
|
|
149
|
+
holds, with its arguments, result and kind from the method's blueprint, and the organism's portrait when it connects.
|
|
150
|
+
A method marked irreversible, one that tears down, drops or deletes, is hinted destructive and made just as the
|
|
151
|
+
console makes it: who must approve what is the organism's to say and the **harness**'s to ask, the files an agent
|
|
152
|
+
works by (its instructions, hooks, settings and skills). A job is followed as a task.
|
|
153
|
+
- **Another account owns nothing** without the boot key, nor does the device while the organism is down. Whoever can
|
|
127
154
|
become every account of a machine holds every organism on it.
|
|
128
|
-
- **The anchor** is the owner no other owner
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
155
|
+
- **The anchor** is the one owner no other owner can drop: the present lobe, or, where there is none, whoever took the
|
|
156
|
+
organism's first invitation. It leaves only by passing the anchor on, and the person present can take a far anchor
|
|
157
|
+
back by dropping it.
|
|
158
|
+
- An owner reaches a lobe through the brain's `ask`, and the lobe sees `brain` as its asker. Through the brain an owner
|
|
159
|
+
creates and moves lobes, adds organs, wires, invites other owners, takes relations, backs up, upgrades and reads
|
|
160
|
+
`state`.
|
|
161
|
+
- **A secret is kept from strangers and siblings, never from owners.** A lobe's cells are a wall against other lobes
|
|
162
|
+
and against the far side, and only a default against accident for owners: `state` shows no cell, so a secret stays
|
|
163
|
+
out of everyday tools and out of a model's sight, as `ps` prints no process's memory. An owner reads all a lobe holds
|
|
164
|
+
by a deliberate act that shows: moving it to a faculty that tells, or taking a backup.
|
|
136
165
|
- The brain counts and enforces, and never judges. It keeps the organism's **character**, `{name, voice, goals}`, and
|
|
137
166
|
answers every owner its **portrait**: this guide, the character, each lobe with its guide, and the first page of its
|
|
138
167
|
`state`.
|
|
139
168
|
|
|
140
|
-
##
|
|
141
|
-
|
|
142
|
-
Quo
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
169
|
+
## Relations and Quo
|
|
170
|
+
|
|
171
|
+
Quo carries asks and replies between organisms, as data and never as code; it has its own specification.
|
|
172
|
+
|
|
173
|
+
**Wards.** An organism's public identity is its **ward**, the name others know it by. For each relation it opens to a
|
|
174
|
+
stranger it draws a fresh ward, so no two strangers can tell they are dealing with the same organism. Where a **relay**
|
|
175
|
+
is wired, a lobe that gives each ward an address of its own, they cannot tell it by where it is reached either. What a
|
|
176
|
+
wire on the network shows, and where an organism asks from, is the network's and the owner's to cover.
|
|
177
|
+
|
|
178
|
+
**Inviting and accepting.** A relation always runs one way: the side that accepted asks, the side that invited answers.
|
|
179
|
+
|
|
180
|
+
- A lobe **invites** through the ear, with **spans**, how long the invitation waits and how long the relation lives,
|
|
181
|
+
and a **note**, free JSON saying what the relation is for, kept at home and never sent.
|
|
182
|
+
- The invitation's whole text, spans and what it says, is signed by the ward drawn for it, so no one who carries it can
|
|
183
|
+
change a word unseen. The signature says the text is the ward's own, never whose the ward is.
|
|
184
|
+
- The other organism **accepts** through its mouth; its first **knock**, the first ask that announces its key, binds the
|
|
185
|
+
relation.
|
|
186
|
+
|
|
187
|
+
**Links.** A **link** is an invitation kept behind a one-time reference, short enough for a QR code. It names the ward
|
|
188
|
+
drawn for it and where that ward is reached, so a link names no one. It is redeemed once at that ward's **zero head**,
|
|
189
|
+
where a being that holds no relation yet may ask. Before saying yes, whoever holds a link reads its **offer** there,
|
|
190
|
+
spending nothing: what the inviter says, how long it waits and how long the relation would live. A link on a domain
|
|
191
|
+
names the public ward, where a name is meant to be known.
|
|
192
|
+
|
|
193
|
+
**The two ends.** Each side holds its own end of a relation:
|
|
194
|
+
|
|
195
|
+
- the **occupant**, the end a lobe gave out, which answers;
|
|
196
|
+
- the **standing**, the end the organism holds after accepting, which the owner wires to the lobes that may ask with it.
|
|
197
|
+
|
|
198
|
+
The brain alone keeps ends and their notes; a lobe keeps no copy. An owner can **hand** a standing to another organism
|
|
199
|
+
of theirs without the place it asks being told: there `taking` draws a key, here `cede` forgets the standing and
|
|
200
|
+
answers it sealed to that key, and there `take` keeps it. Its addresses, keys and the numbering of its asks go on as
|
|
201
|
+
if from one device, so nothing the place receives tells it the standing moved. An app or a window of the owner's asks
|
|
202
|
+
it.
|
|
203
|
+
|
|
204
|
+
**At the ear.** The ear opens each sealed box with `key` and never decides anything; a stranger hears silence, and the
|
|
205
|
+
ear holds no place for an answer while a node works.
|
|
206
|
+
|
|
207
|
+
- An ask over a relation runs at most once; one taken already hears `repeated`.
|
|
208
|
+
- A stranger's ask at the zero head changes nothing by default, since nothing can tell its copy from a second ask; a
|
|
209
|
+
change goes over a relation.
|
|
210
|
+
- A relation ends from either side, never half.
|
|
211
|
+
- A **box**, one ask or one reply, sealed, is at most 1 MiB; more crosses in pieces.
|
|
212
|
+
- A lobe never sees a ward or a key, only an ID. At most one lobe is the ear's `front`, which answers strangers for the
|
|
213
|
+
organism's public part, what it may be asked among it.
|
|
214
|
+
- An organism that cannot be dialed holds a **line** to one that is always on, and asks travel both ways over it.
|
|
215
|
+
|
|
216
|
+
## Code: faculties, the library and versions
|
|
217
|
+
|
|
218
|
+
A **faculty** is one JavaScript module the cage runs, a class extending `Faculty` whose static `blueprint` names its
|
|
219
|
+
name, version and methods. Its source is one string named by its SHA-256 hash, its **digest**, so the version is inside
|
|
220
|
+
the digest. Each ask runs on a fresh instance, in a cage with no clock, no randomness and no I/O: chance comes from the
|
|
221
|
+
stamp's seed, time from the stamp, and the world only by asks. Code is logic; data is cells. A faculty proves itself by
|
|
222
|
+
**evidence**: pieces of its world, replayed exactly.
|
|
223
|
+
|
|
224
|
+
The **library** keeps every faculty by its digest and never runs one. Code enters it by four **roads** alone, each
|
|
225
|
+
taken on an owner's word, never pushed in:
|
|
183
226
|
|
|
184
227
|
1. **The genome's**: the default faculties, at install and upgrade.
|
|
185
228
|
2. **The installer's**: the host's organs and the faculties it ships, from its **channel**, the host's own way of
|
|
186
|
-
shipping code
|
|
187
|
-
|
|
188
|
-
3. **A source's**: everything else, from any lobe an owner names that answers `get` and `told
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
author's
|
|
193
|
-
asker to create sealed.
|
|
194
|
-
4. **An owner's hand**: a faculty's text an owner's `add` carries itself, kept
|
|
229
|
+
shipping code. Among them are the floor's: the skins of the console and the screen, the plain look for the window,
|
|
230
|
+
and the repo faculties.
|
|
231
|
+
3. **A source's**: everything else, from any lobe an owner names that answers `get` and `told`, here or far over a
|
|
232
|
+
library's standing. A repo lobe is such a source: it tells a version once a tagged commit holds it, and its
|
|
233
|
+
`versions.json` names each version's digest. The library hashes the text itself and keeps it only if the digest
|
|
234
|
+
matches, and only if that name and version were never kept under another digest; an owner's `second` takes another
|
|
235
|
+
author's faculty under a name of the owner's own. A faculty a far place offers is kept as given by that place, for
|
|
236
|
+
its asker to create sealed.
|
|
237
|
+
4. **An owner's hand**: a faculty's text an owner's `add` carries itself, kept as `hand@<version>`, under the same
|
|
195
238
|
walls. It is how a bare host gets its first source.
|
|
196
239
|
|
|
197
|
-
A faculty from a source carries its evidence as an **asset**, a file
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
An owner **creates** a lobe on a kept digest, naming its wires, and **moves** it to another
|
|
202
|
-
another faculty
|
|
203
|
-
|
|
204
|
-
back or moves again, and no size of a lobe stops it.
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
240
|
+
A faculty from a source carries its evidence as an **asset**, a file kept with its version, data that runs nothing, so
|
|
241
|
+
the proof outlives its repo. One with no evidence is still allowed, shown as unproven. What the genome or an installer
|
|
242
|
+
lays is proven by the release that ships it.
|
|
243
|
+
|
|
244
|
+
**Creating and moving.** An owner **creates** a lobe on a kept digest, naming its wires, and **moves** it to another
|
|
245
|
+
version in place, or to another faculty. The move asks the new version's `migrate` once, keeps the old version if it
|
|
246
|
+
fails, and leaves unwired what the new version newly declares, for the owner to wire. A landed move keeps one step back
|
|
247
|
+
until the owner settles it, goes back or moves again, and no size of a lobe stops it.
|
|
248
|
+
|
|
249
|
+
The library keeps no old version that no lobe or step names, unless an owner spares it: each boot, and each lobe leaving
|
|
250
|
+
a version, sweeps them, so a version an owner adds stays for a lobe to move to, an older one too. A removed version keeps
|
|
251
|
+
its digest, so no other text can ever take it.
|
|
252
|
+
|
|
253
|
+
**What never moves alone.** Lobes that decide who someone is or what code is, `brain`, `library`, `ear` and `mouth`,
|
|
254
|
+
are **immutable**: they move only with the genome. A present lobe decides no one, so the person present, never a model
|
|
255
|
+
or a far owner, moves the console's or the screen's skin to any faculty by `version`. The choice is the home's: an
|
|
256
|
+
upgrade moves only a skin no one chose, and `nervur start --floor`, at the device, lays again the skin its **port**, the
|
|
257
|
+
installer for its kind of host, gave, its design with it. No skin and no design can hold anyone captive.
|
|
212
258
|
|
|
213
259
|
## Organs
|
|
214
260
|
|
|
215
|
-
An organ is `{blueprint, reach, half, code?}`. Its host half is a WebAssembly **component** given exactly the imports
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
261
|
+
An organ is `{blueprint, reach, half, code?}`. Its host half is a WebAssembly **component** given exactly the imports its
|
|
262
|
+
reach names, or a **native half** built for one host. No host half's program ever crosses Quo:
|
|
263
|
+
|
|
264
|
+
- On a host with a body, an organ from a repo comes only from a repo lobe of the organism's own, pulled and built in
|
|
265
|
+
its body through `shell`, then added by an owner's `addOrgan` under a fixed ID.
|
|
266
|
+
- A host without a body takes faculties only, plus the organs from its installer and the halves its embedder's build
|
|
267
|
+
brings, a site's, an app's or a pilot's, each admitted by `addOrgan`.
|
|
268
|
+
|
|
269
|
+
A host half that fails shows unavailable and restarts on its own. An organ's judgment lives in its skin lobes, which hold
|
|
270
|
+
its secrets and settings: logic lives in lobes, drivers in organs, and a new use is a new plain lobe composing skin
|
|
271
|
+
lobes, seldom a new organ.
|
|
222
272
|
|
|
223
273
|
The organs Nervur holds: `network` carries Quo and the web; the console asks its present lobe `line` with each line
|
|
224
274
|
typed; `shell` runs programs as the body; `disk` keeps files under one folder.
|
|
225
275
|
|
|
226
276
|
## Building well
|
|
227
277
|
|
|
228
|
-
What Nervur leaves to whoever builds
|
|
278
|
+
What Nervur leaves to whoever builds; nothing here binds an organism.
|
|
229
279
|
|
|
230
|
-
- **Code is logic, data is cells.** A faculty is one module, written in any language that yields
|
|
280
|
+
- **Code is logic, data is cells.** A faculty is one module, written in any language that yields one and bundled by its
|
|
231
281
|
repo's build. A table, a content or a model it serves is laid in its lobe's cells, by `migrate` or by asks, never in
|
|
232
|
-
its source, so a version carries only what changed of the logic.
|
|
233
|
-
- **Logic in lobes, drivers in organs.** Whatever can be decided is decided in a lobe over an organ
|
|
234
|
-
running a model or transcoding media, is a driver's work and stands in an organ, its host half native code
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
the asker's switch on.
|
|
282
|
+
its source, so a new version carries only what changed of the logic.
|
|
283
|
+
- **Logic in lobes, drivers in organs.** Whatever can be decided is decided in a lobe over an organ. Heavy computation,
|
|
284
|
+
running a model or transcoding media, is a driver's work and stands in an organ, its host half native code where it
|
|
285
|
+
must be: a driver on a Pi that moves a robot has its source in its owner's repo, is built on the Pi, and reaches the
|
|
286
|
+
motor's device. The shape that repeats is a plain lobe composing skin lobes: the skin lobes hold what reaches the
|
|
287
|
+
world and its secrets, and the plain lobe holds the use, reaching the world only by asking them and other beings.
|
|
288
|
+
- **Signal or letter.** An ask whose loss matters is a letter; one that will be asked again anyway is a signal. An ask
|
|
289
|
+
back, a letter taken again or a durable ask sent again is a cue to read cells, never proof that something happened
|
|
290
|
+
once: a node that owes one and meets `unavailable` drops it, the asker's cells staying the truth, or posts it as a
|
|
291
|
+
letter that waits for the asker to come back.
|
|
243
292
|
- **Once, far.** What an ask sent far did stays done, so an ask that must not run twice, a payment, carries a key of its
|
|
244
|
-
asker's, which the far lobe keeps and answers once. On a window of one, an asker
|
|
293
|
+
asker's, which the far lobe keeps and answers once. On a window of one, an asker that must know an earlier box will not
|
|
245
294
|
still run asks once more. A lobe working step by step names its next step in its answer.
|
|
246
295
|
- **Choosing by the nerves.** A lobe reads its statuses and answers `unavailable`, takes another path, or orders its
|
|
247
|
-
wiring again; at `left` it forgets what it keeps of that far organism,
|
|
248
|
-
relation, so a note on an occupant is a belief rooted in the
|
|
249
|
-
being has its organism hold more standings.
|
|
296
|
+
wiring again; at `left` it forgets what it keeps of that far organism, a token for example. Whoever knocks first holds
|
|
297
|
+
the relation, so a note on an occupant is a belief rooted in how the invitation was handed over. A lobe that needs
|
|
298
|
+
more asks at once to one being has its organism hold more standings.
|
|
250
299
|
- **Skin lobes.** Every use of an organ is a skin lobe of its own: `network` has the ear, the mouth and the web's,
|
|
251
300
|
`shell` the jailer and every lobe that runs programs. A skin lobe lets a secret reach its organ only as an ask's
|
|
252
|
-
input, never in words the organ keeps. A lobe stands
|
|
253
|
-
it keeps,
|
|
254
|
-
|
|
255
|
-
not be lost, and never asks its organ again from inside the organ's ask back, which
|
|
256
|
-
follows in its cells and starts it by an alarm, which the scheduler keeps.
|
|
257
|
-
- **Long work
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
- **Two organisms nobody can dial** both hold lines to one always on, which passes each ask down the line that
|
|
261
|
-
its ward and carries the reply back, unread. A relay, which gives a ward an address of its own, is a repo's
|
|
262
|
-
genome neither holds nor forbids.
|
|
301
|
+
input, never in words the organ keeps. A lobe stands in front of an organ for other lobes only where they must share
|
|
302
|
+
what it keeps, one account's token for example, and is then an ordinary asker of their skin lobe.
|
|
303
|
+
- **An organ's long work** answers at once and asks its skin lobe back. A skin lobe serving another lobe asks it back in
|
|
304
|
+
turn, by a letter where it must not be lost, and never asks its organ again from inside the organ's ask back, which
|
|
305
|
+
waits on its answer: it keeps what follows in its cells and starts it by an alarm, which the scheduler keeps.
|
|
306
|
+
- **Long work** is made of pieces, each its own ask well within the longest timeout, and judged by progress: a piece
|
|
307
|
+
that times out is asked again, and the whole fails only once it has not moved for the span it may stand still, never
|
|
308
|
+
because one piece was slow.
|
|
309
|
+
- **Two organisms nobody can dial** both hold lines to one that is always on, which passes each ask down the line that
|
|
310
|
+
proved its ward and carries the reply back, unread. A relay, which gives a ward an address of its own, is a repo's to
|
|
311
|
+
build; the genome neither holds nor forbids one.
|
|
263
312
|
- **A builder delivers into its buyer's repo.** The buyer's repo lobe invites the builder with a writer's standing
|
|
264
|
-
scoped to the folders it delivers, a note and a span
|
|
313
|
+
scoped to the folders it delivers, a note and a span. The builder's repo lobe pulls that scope, writes what it
|
|
265
314
|
delivers and pushes, and the buyer's lobe guards it. The standing ends and the builder's lobe is torn down, so the
|
|
266
315
|
builder keeps nothing of the buyer's, and the buyer keeps what was delivered. An update is a job again, on the buyer's
|
|
267
316
|
word, and a version enters the buyer's library from the buyer's own repo lobe.
|
|
268
317
|
|
|
269
318
|
## Repos
|
|
270
319
|
|
|
271
|
-
|
|
272
|
-
only through asks. What
|
|
273
|
-
|
|
320
|
+
You build on Nervur without changing anything of it: you write faculties and organs in repos of your own, and your
|
|
321
|
+
nodes act only through asks. What travels as code stands in a **repo**, kept by the **repo faculties**, the floor's
|
|
322
|
+
skins of `shell` and `disk`, in `@nervur.org/floor`:
|
|
274
323
|
|
|
275
|
-
- **The jailer**, `nervur.repos`, one per organism with a body, laid
|
|
276
|
-
|
|
277
|
-
`repos/node_modules/@nervur.org/genome`, one folder up from every repo, at the version the organism runs
|
|
324
|
+
- **The jailer**, `nervur.repos`, one per organism with a body, laid when first wanted. It alone runs git, keeps each
|
|
325
|
+
repo's files at `repos/<name>`, grants each folder to one repo lobe, and lends the genome at
|
|
326
|
+
`repos/node_modules/@nervur.org/genome`, one folder up from every repo, at the version the organism runs. The genome
|
|
278
327
|
carries this guide, `authoring.md` and `changelog.md` in its `docs/`.
|
|
279
|
-
- **A repo lobe**, on `nervur.repo`, one per repo per organism
|
|
280
|
-
and guards its own `main` by two checks
|
|
281
|
-
owners hold it to, as the lobe's owner chose it, never a writer.
|
|
282
|
-
**writer's** (pull and push
|
|
328
|
+
- **A repo lobe**, on `nervur.repo`, one per repo per organism. It commits, pulls and pushes git bundles over standings,
|
|
329
|
+
and guards its own `main` by two checks: Nervur's check of the repo's parts, and the repo's own `conform`, the choices
|
|
330
|
+
its owners hold it to, as the lobe's owner chose it, never a writer. A standing on it is a **reader's** (pull), a
|
|
331
|
+
**writer's** (pull and push, optionally scoped to folders) or a **library's** (read what was told). Only `main` and
|
|
283
332
|
its tags move between lobes.
|
|
284
|
-
- **
|
|
285
|
-
|
|
286
|
-
`.env`
|
|
287
|
-
fails
|
|
288
|
-
and ends with its standing. A lobe an owner wires to the repo lobe may run and commit, but while a writer's
|
|
289
|
-
stands on it only the
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
**Authoring and running stand apart
|
|
293
|
-
and push along their standings. Code runs only where
|
|
294
|
-
`run`, a key or a runner's invitation.
|
|
295
|
-
a lobe to it. A release is published only by a `run` of the publish script on a repo lobe,
|
|
296
|
-
runner
|
|
297
|
-
which are the writer's, so it catches a mistake
|
|
298
|
-
`conform`.
|
|
299
|
-
|
|
300
|
-
A repo's version is its root `package.json`'s; a commit that raises it is tagged `v<version
|
|
301
|
-
every part it holds, whose bytes never change after. A repo names no genome: the organism lends it.
|
|
302
|
-
folders
|
|
303
|
-
its `package.json` scripts, `gate` and `conform` always
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
333
|
+
- **Commands and keys.** A repo declares commands alone, the scripts of its `package.json`. Keys belong to a copy of the
|
|
334
|
+
repo, never to the repo: its repo lobe keeps them in its cells, never answers them, masks them in all it tells, and
|
|
335
|
+
writes `.env` from them before each run. What protects a command is its key, never a role: a script without its key
|
|
336
|
+
fails in its own words. An owner asks `run`, `setToken` and `credential`; a credential renews itself before it
|
|
337
|
+
expires and ends with its standing. A lobe an owner wires to the repo lobe may run and commit, but while a writer's
|
|
338
|
+
standing stands on it only the lobe it names `author` commits. A **runner**, a far organism given its own invitation,
|
|
339
|
+
runs only the scripts that invitation names.
|
|
340
|
+
|
|
341
|
+
**Authoring and running stand apart.** Authors work on their own organism, in their own repo lobe, checked at each
|
|
342
|
+
commit, and push along their standings. Code runs only where its owners ask: a reader, a writer or a library never
|
|
343
|
+
reaches `run`, a key or a runner's invitation. The two meet only at a release: a version leaves by its digest, and an
|
|
344
|
+
owner moves a lobe to it. A release is published only by a `run` of the publish script on a repo lobe, asked by an
|
|
345
|
+
owner or a runner, on an organism its owner chooses, an authoring one among them. The gate runs the tests of the code
|
|
346
|
+
that came, which are the writer's, so it catches a mistake, never a dishonest writer: what an owner holds against
|
|
347
|
+
writers is written in `conform`.
|
|
348
|
+
|
|
349
|
+
**A repo's shape.** A repo's version is its root `package.json`'s; a commit that raises it is tagged `v<version>`, and
|
|
350
|
+
that tag **tells** every part it holds, whose bytes never change after. A repo names no genome: the organism lends it.
|
|
351
|
+
Its conventions are folders, `faculties/`, `organs/` and `designs/`; everything else is its owners', packages included.
|
|
352
|
+
Its commands are its `package.json` scripts, `gate` and `conform` always among them.
|
|
353
|
+
|
|
354
|
+
**Its harness and its guides.** A repo's **harness**, its skills among it, says how it is authored, for models alone,
|
|
355
|
+
and Nervur shapes nothing of it. A faculty's **guide**, in its blueprint, says how it is run and used, read by its
|
|
356
|
+
owners, by a lobe wired to it and by whoever holds a standing on its lobe. How a faculty is run is its guide, never a
|
|
357
|
+
skill.
|
|
358
|
+
|
|
359
|
+
**Authoring a repo, anywhere.** A session authors a repo opened in that repo's own folder, and everything it needs is
|
|
360
|
+
there: this guide and the two papers beside it, one folder up in the lent genome's `docs/`, at
|
|
361
|
+
`repos/node_modules/@nervur.org/genome/docs/`, and the repo's own harness, skills and gate in the repo. Its harness,
|
|
362
|
+
its owners' own for whatever agent they bring, takes this guide in at the start of every session, so whoever authors
|
|
363
|
+
starts holding Nervur, on any organism. Nervur lends knowledge alone, for any agent and any model, and lays no harness.
|
|
364
|
+
A repo begins empty, or as the child of a lobe that raises repo lobes and lays its owners' boilerplate, a harness among
|
|
365
|
+
it, as its first commit, to be pulled and authored.
|
|
315
366
|
|
|
316
367
|
## The screen and looks
|
|
317
368
|
|
|
318
|
-
A screen's **home** is the organism it
|
|
319
|
-
of their own, as
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
369
|
+
A screen's **home** is the organism it belongs to. A **place** is any lobe its person stands on, a far organism's or one
|
|
370
|
+
of their own, as the window draws it.
|
|
371
|
+
|
|
372
|
+
- **Trees, not pages.** Lobes answer **trees**, plain data, from a reading `draw`; the screen composes them, diffs them
|
|
373
|
+
and patches what changed. No script, style or address can be written in a tree. A region a sealed lobe draws is drawn
|
|
374
|
+
for the lobe whose slot asked it, and that lobe hears its presses. A gesture is another hand on a control the
|
|
375
|
+
keyboard reaches.
|
|
376
|
+
- **Sealed lobes.** Whoever creates a lobe may create it **sealed**: it hears and answers, reads its own cells and its
|
|
377
|
+
faculty's assets, and orders no wire, so code someone else wrote runs and reaches nothing.
|
|
378
|
+
- **A place with no drawing of its own** is drawn by the floor's window from its describe: its methods, and a field for
|
|
379
|
+
each argument. So one describe gives a place's forms, as it gives Quo's describe and the console's tools.
|
|
380
|
+
- **The window** is the screen's skin lobe. It draws in a **design** (tokens, themes and components, built into a
|
|
381
|
+
**look** faculty), which is no part of the genome. It creates its design lobes sealed and wears the design its port
|
|
382
|
+
gave it, by the name `design`, until an owner's `wear` chooses another.
|
|
383
|
+
- **Above the page.** What a window hands the host to lay above the page stands outside every tree: no place's tree or
|
|
384
|
+
stylesheet covers or presses it, and no place's tree can forge a consent the window holds.
|
|
385
|
+
|
|
386
|
+
The floor's window is the least that lets a person use what Nervur promises from a screen. It shows the organism and a
|
|
387
|
+
place by what they describe; carries a press past the person's yes where the press binds them; takes a link only with a
|
|
388
|
+
yes that knows who invites and what they say; and leaves what it took. It says the warnings and every consent in the
|
|
389
|
+
home's own words and lays a way out above the page. A note its caller gives at a link's yes is kept beside the standing
|
|
390
|
+
and never sent to the place, and at a place it took, a press the person consents to ends the standing whole and returns
|
|
391
|
+
them home. Everything else a person meets, pages laid out of parts, boards, lists, words in their language, is built in
|
|
392
|
+
a window or a design of one's own: Where Nervur stops, below, says how. A site is another repo's, and in a browser a page
|
|
393
|
+
embeds the installer as plain files.
|
|
339
394
|
|
|
340
395
|
## Hosts
|
|
341
396
|
|
|
342
|
-
One genome on every host; only host halves differ. The engine is QuickJS and the store SQLite with every
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
397
|
+
One genome runs on every host; only the host halves differ. The engine is QuickJS and the store is SQLite with every
|
|
398
|
+
page encrypted, everywhere.
|
|
399
|
+
|
|
400
|
+
- **A machine** (a server, a desktop, a Pi, a NAS) has a body, and its Node installer gives `nervur install` and
|
|
401
|
+
`nervur update`.
|
|
402
|
+
- **A browser** has no body; its boot key is a file of the site.
|
|
403
|
+
- **A phone's app** embeds the browser port, its store in the app's own files and its boot key in the keychain.
|
|
404
|
+
- **An edge** keeps its boot key in its object's own storage. It is laid from another machine, from its port's
|
|
405
|
+
**cargo**, the genome and that host's parts built into the files the host's runtime takes, either by hand or by a
|
|
406
|
+
**pilot**, a repo's faculty and organ that lay and keep an organism on a host from afar.
|
|
407
|
+
- **A server with no one present** is laid by `nervur install --claim`. An edge and such a server are each claimed by
|
|
408
|
+
whoever names its **claim**, a secret drawn and set on the host as it is laid, by which the organism's first
|
|
409
|
+
invitation is fetched.
|
|
410
|
+
|
|
411
|
+
On a server the machine is root's: ports, DNS and services are laid outside the graph by whoever holds the machine,
|
|
412
|
+
never by the organism. A server holds as many organisms as it has accounts, one each, each with a body of its own, a
|
|
413
|
+
second account where its organs run, so none sees another's files. Its administrator prepares each person's two
|
|
414
|
+
accounts once, and the person installs alone. Authoring's _A server_ says what the administrator and the person each
|
|
415
|
+
do, for a machine you own, one you hold an account on, and one laid for you.
|
|
416
|
+
|
|
417
|
+
## Updates
|
|
418
|
+
|
|
419
|
+
**A new version is tried before it is kept.** It boots in place on the store itself, held, writing nothing of it but its
|
|
357
420
|
log and the values it lays, so the store's log as it stood is the whole way back, kept aside with the old package on a
|
|
358
|
-
machine. Nothing of the store is copied, and an update costs what its own
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
a version
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
421
|
+
machine. Nothing of the store is copied, and an update costs what its own changes move, never the size of the store.
|
|
422
|
+
The new version boots with the world held off, and is kept, or the old one comes back by itself.
|
|
423
|
+
|
|
424
|
+
- The update asks nothing of the organism but to stop, so it moves one no one is present at as it moves one owned at
|
|
425
|
+
its console. Until 1.0.0 it is abrupt: a run the body has going is lost as in a crash, and its lobe is told so.
|
|
426
|
+
- What the installer ships, its organs' halves and its faculties, moves at the new version's first boot; a lobe an owner
|
|
427
|
+
moved to a later version stays where it is.
|
|
428
|
+
- From afar, `upgrade` names a version and its digest, and nothing else lands.
|
|
429
|
+
- An organism never moves itself: a version lands only where an owner names it, and nothing asks for a newer one on a
|
|
430
|
+
clock.
|
|
431
|
+
- A start, a trial and a stop wait on the organism's silence, never on a fixed span: while it opens or ends it says it
|
|
432
|
+
lives, so a store that takes long to open is waited for, and a process that says nothing for the longest wait, or
|
|
433
|
+
ends unasked, fails the step and says why.
|
|
434
|
+
|
|
435
|
+
**Two moves stand apart.** A faculty's new version is its author's: its `migrate` converts its own cells by its own
|
|
436
|
+
logic, and Nervur only runs it. Nervur's own new version knows no faculty, and from 1.0.0 breaks no contract one stands
|
|
437
|
+
on. Until 1.0.0 Nervur goes forward only: a genome names its floor, `FLOOR`, the oldest release whose store it carries
|
|
438
|
+
forward, and refuses a store a genome below it last booted, saying to update to the floor's release first, then to the
|
|
439
|
+
newest. No installer carries an older release to do that for you, so a store, a backup or a move from below the floor
|
|
440
|
+
is refused as it stands, nothing opened and the store untouched.
|
|
375
441
|
|
|
376
442
|
## The floor and the licence
|
|
377
443
|
|
|
378
|
-
Above the genome and the ports everything is faculties and organs and the data they carry, and the genome names
|
|
379
|
-
|
|
444
|
+
Above the genome and the ports, everything is faculties and organs and the data they carry, and the genome names nothing
|
|
445
|
+
built of them, so all of it, Nervur's own defaults among it, can be rebuilt or replaced by anyone.
|
|
446
|
+
|
|
447
|
+
The **floor** is only what the genome and the ports cannot work without:
|
|
380
448
|
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
`disk`, the jailer and the repo lobe, which a port with a body lays the first time
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
bytes the port gave.
|
|
449
|
+
- the default skins of the organs a port lays: the console's terminal and the screen's window, the two skins of
|
|
450
|
+
presence;
|
|
451
|
+
- the repo faculties of `shell` and `disk`, the jailer and the repo lobe, which a port with a body lays the first time
|
|
452
|
+
an owner wants a repo;
|
|
453
|
+
- the plain look the window draws with.
|
|
454
|
+
|
|
455
|
+
The window is the least that lets a person live with no design, as The screen and looks tells. Its own words are
|
|
456
|
+
English; a design says them in any other language. Each of the floor's faculties stands on what the genome publishes,
|
|
457
|
+
as any repo does, and holds no privilege: the genome lays no skin, a port names the floor's in its configuration as an
|
|
458
|
+
owner could name another repo's, and a skin whose stored text is damaged is read again from the bytes the port gave.
|
|
391
459
|
|
|
392
460
|
## Where Nervur stops
|
|
393
461
|
|
|
394
|
-
Nervur gives the mechanics no one could build alone, and nothing more: an organism and its keys, an invitation taken
|
|
395
|
-
|
|
462
|
+
Nervur gives the mechanics no one could build alone, and nothing more: an organism and its keys, an invitation taken and
|
|
463
|
+
its keys kept in the cells, asks one way over it, the owner as root, the cage, the store, backups and moves, the
|
|
396
464
|
screen's safety, and the ports that lay it on each host. Everything a person meets, holds or is offered is built on it
|
|
397
|
-
by whoever builds, in faculties, organs, designs and apps of their own: a list of places
|
|
465
|
+
by whoever builds, in faculties, organs, designs and apps of their own: a list of blocked places, a report, a page of
|
|
398
466
|
what a person can do with a place, a board of many, a keeper of boot keys, a copy of an organism kept somewhere safe,
|
|
399
|
-
words in every language, a page laid out as one likes. Nervur will not build these for anyone, however often
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
467
|
+
words in every language, a page laid out as one likes. Nervur will not build these for anyone, however often asked:
|
|
468
|
+
each is one way among many, and the first one built into the kernel would close the rest.
|
|
469
|
+
|
|
470
|
+
What is asked of Nervur is weighed by one question: without it, with no design and no app, does something Nervur already
|
|
471
|
+
promises break, or could no one build it on what is published? Only three answers say yes:
|
|
472
|
+
|
|
473
|
+
- nothing published reaches it;
|
|
474
|
+
- it can be built, but what Nervur promises could then not be proven;
|
|
475
|
+
- the only way to build it breaks a promise: a key held outside the cage, a wait where something could tell, two of a
|
|
476
|
+
person's relations linked.
|
|
477
|
+
|
|
478
|
+
Easier, faster, nicer or often asked is none of them. What enters comes with its proof, a test played from outside as a
|
|
479
|
+
stranger would play it, failing before and holding after. Where the answer is no, the answer is how to build it, in
|
|
407
480
|
`authoring.md`, never a change to Nervur.
|
|
408
481
|
|
|
409
482
|
Nervur is Bookarest Digital SRL's, under the Functional Source License (`FSL-1.1-ALv2`): anyone reads it, uses it and
|
|
@@ -419,4 +492,45 @@ years after it is published.
|
|
|
419
492
|
| how a faculty is run and used | its `guide`, in its blueprint, and its node's describe |
|
|
420
493
|
| what an organism is and holds now | the brain's `portrait` and `state` |
|
|
421
494
|
| how a repo is authored and released | `authoring.md`, then the repo's harness, its skills first |
|
|
422
|
-
| what crosses between two organisms | Quo's own
|
|
495
|
+
| what crosses between two organisms | Quo's own specification, by its chapter |
|
|
496
|
+
|
|
497
|
+
## Words
|
|
498
|
+
|
|
499
|
+
| Word | What it means |
|
|
500
|
+
| ------------- | ---------------------------------------------------------------------------------------- |
|
|
501
|
+
| organism | a person's, group's or agent's own instance of Nervur, on one device |
|
|
502
|
+
| genome | Nervur's kernel, the same on every host |
|
|
503
|
+
| port | the installer for one kind of host, which fills the genome's seams there |
|
|
504
|
+
| self, body | the organism's own account, and the second account where its programs run |
|
|
505
|
+
| node | anything in an organism, under an ID: an organ, a lobe or a far organism |
|
|
506
|
+
| organ | a driver: a blueprint in the graph and a host half on the device |
|
|
507
|
+
| faculty, lobe | a module of pure code, and one instance of it, with its own cells |
|
|
508
|
+
| cells | a lobe's private part of the organism's memory |
|
|
509
|
+
| placeholder | a need a node declares, by name |
|
|
510
|
+
| wire | one placeholder joined to one node, one way, written by the brain alone |
|
|
511
|
+
| skin lobe | a lobe that declares a placeholder named after an organ: the organ's way into the graph |
|
|
512
|
+
| ask | a method, its arguments and a timeout; it ends exactly once |
|
|
513
|
+
| signal | an ask kept in memory, lost in a crash |
|
|
514
|
+
| letter | an ask kept in the organism's memory until taken, exactly once |
|
|
515
|
+
| job | a handle a node answers at once for long work, given back to ask how it ended |
|
|
516
|
+
| owner | whoever may ask the brain |
|
|
517
|
+
| present | at the device itself, by its console or its screen |
|
|
518
|
+
| anchor | the owner no other owner can drop |
|
|
519
|
+
| Quo | the protocol organisms ask each other over |
|
|
520
|
+
| ward | an organism's identity in Quo, public or fresh for each relation |
|
|
521
|
+
| relation | an invitation accepted: one side asks, the other answers |
|
|
522
|
+
| standing | the end of a relation an organism holds after accepting, which asks |
|
|
523
|
+
| occupant | the end of a relation a lobe gave out, which answers |
|
|
524
|
+
| link | an invitation behind a one-time reference, short enough for a QR code |
|
|
525
|
+
| zero head | where a being with no relation yet may ask a ward |
|
|
526
|
+
| line | a connection an undialable organism holds to one always on |
|
|
527
|
+
| digest | a faculty's SHA-256, its identity and its version |
|
|
528
|
+
| library | the lobe that keeps every faculty by its digest |
|
|
529
|
+
| evidence | pieces of a faculty's world, replayed exactly to prove it |
|
|
530
|
+
| sealed | a lobe that hears and answers but orders no wire |
|
|
531
|
+
| tree | what a lobe draws: plain data, never script, style or address |
|
|
532
|
+
| design, look | the tokens, themes and components a window draws in, and the faculty they are built into |
|
|
533
|
+
| floor | the defaults the genome and the ports cannot work without |
|
|
534
|
+
| `FLOOR` | the oldest release whose store a genome carries forward |
|
|
535
|
+
| harness | the files an agent works by in a repo: instructions, hooks, settings, skills |
|
|
536
|
+
| wall, default | a limit that protects someone other than the owner, and a limit an owner can change |
|