0.7.1, 0.7.2, 0.7.3 — a trilogy in sixteen minutes

06:52, 06:54, 06:56. Three releases in sixteen minutes. This is not a story about an outage — nothing was burning, nobody called. It is a story about one mistake having three floors, each revealed only after the one above it is closed.

Context: an instance pulls the engine's files into itself, according to a list of paths. The list is called the manifest. A script reads the manifest and copies what is on it.

0.7.1 — floor one. The manifest listed the generated route map. The problem: that file is produced from the INSTANCE's route directory and enumerates pages the engine knows nothing about. If it belonged to the engine, every instance with its own subpages would lose them on every synchronisation. Bonus: in the engine repository that file is in `.gitignore`, so a fresh clone simply does not have it — meaning the check mode reported an error on it always, on every run, for everyone. On top of that the manifest lived in two different places and two scripts read it from three. One of them wrote it where the other never looked.

The fix: the manifest returns to a single canonical location and — this is the pretty part — goes onto its own list. From now on it synchronises together with the engine, so an instance cannot be left with an old list of paths and quietly miss files added in a newer version. The script detects that the manifest changed and makes a second pass, now against the new list.

0.7.2 — floor two, two minutes later. Since the script is on the list it executes, it overwrites its own file during synchronisation. Underneath a running interpreter. Bash reads a script from disk as it goes — at three kilobytes it usually holds the whole thing in a buffer and gets away with it, but there is no guarantee whatsoever, and the failure symptom is executing garbage halfway through an operation that copies files.

The fix: as its first move the script relocates to a temporary directory and works from there. The original can then be overwritten with impunity.

And here comes the moment that made this worth writing down. On the first attempt to update an older instance — still with the old script — the console spat out: `line 58: z: command not found`. The letter `z`. That was bash landing in the middle of the freshly replaced contents of its own file and trying to run a fragment of it as a command. Exactly the scenario described two minutes earlier as theoretical.

0.7.3 — floor three, another two minutes. Since the manifest had proved unreliable, a full audit followed: every file in the engine repository compared against the list. It turned out two files had dropped off by mistake. One of them is wired into the step that precedes building — meaning a freshly created instance would not have built at all. They came back. Every remaining file outside the manifest is outside it on purpose, and from this version that fact is written down, one by one.

The moral, if anyone needs one: a mechanism that updates itself has to be designed on the assumption that the ground will shift underneath it mid-update. Three versions, sixteen minutes, one letter `z`.