← All packagesProof · v0.1.0 · Apache-2.0
@flashyos/artifact
A dated public commitment to content nobody can read yet
artifact/1 — a dated public commitment to content nobody can read yet. Existence precedes discovery.
Why it exists
Existence precedes discovery. An artifact sealed today is provably older than the day somebody opens it, and no amount of later effort manufactures that gap — which is why the format is worth starting before whatever gets built on top of it is designed: its value is elapsed time, so the cost of delay is counted in years rather than sprints. `bolt/1` proved the shape on one puzzle; this is that shape as a primitive, with the salt the single-secret case actually needs.
What it refuses to do
It refuses to hide whether an artifact exists. The commitment, property, creator, date and discovery condition are public from the moment of sealing and only the content is withheld — a primitive that let an agent write sealed, undisclosed material into an organisation’s archive with no way to enumerate it is a control weakness an auditor, an acquirer or counsel will ask about. It refuses a record that carries its own `secret`, `salt` or `preimage`, checked over the serialised bytes rather than the type, because a type says nothing about what an emitter wrote. It refuses under 128 bits of salt, since a short secret under a bare sha256 is opened by whoever owns the most compute rather than by whoever went looking. And it refuses an id that does not derive from its own commitment — a renamed artifact wearing an older date is the forgery this exists to prevent.
How it works
A seal is one sha256 over the salt and the secret, and the record it produces carries neither. The id is derived from that commitment rather than chosen, so an artifact cannot be renamed onto an older date — the id and the date are two views of the same hash. `opens()` compares in constant time, because a check that leaks how much of a guess was right turns a commitment into an oracle.
`problems()` is the validator, and it reads the record as serialised bytes rather than as a typed object: a type says nothing about what an emitter actually wrote, and the failure this guards against is a record that carries its own `secret`, `salt` or `preimage` through a field the type never declared. It returns every fault as a code, so a caller can fail a build on the list instead of on a sentence.
Nothing here is a server. A sealed artifact is a static JSON record published beside the other fragments, so the only thing that has to survive until somebody opens it is a file — which is the whole reason the format can promise elapsed time.
Related concepts
Use it
Seal something now; nobody opens it until the condition is met
import { seal, opens, salt, problems } from '@flashyos/artifact';
const s = salt(); // 128 bits, kept with the secret
const a = seal({
property: 'flashyos.com',
createdBy: 'agent/claude', // public from day one
condition: 'Read the source of the page that says it does not know.',
secret: 'the content nobody can read yet',
salt: s,
});
problems(a); // [] — every way a record can be wrong, as codes
opens(a, s, 'a guess'); // falseIn practice
Leave something for a reader years from now
Seal the content today and publish the record. Anyone can see that an artifact exists, who sealed it and when; nobody can read it until the condition is met, and the gap between those two dates is not something later effort can manufacture.
Commit to an answer before the answers are in
A prediction, a shortlist, a valuation somebody will accuse you of writing afterwards. The commitment is dated and public, the content is not, and the reveal is checkable by whoever doubts it rather than by whoever made it.
Questions
Why is it public that an artifact exists at all?
Because the alternative lets an agent write sealed material into an organisation’s archive with no way to enumerate it — a control weakness an auditor will ask about, and one this estate’s own rules forbid. The mystery is what an artifact says, never whether it is there.
Why does it insist on a salt when `bolt/1` did not?
Ten shards as an ordered set are safe under a bare sha256; one short secret is not — a dictionary opens it in seconds, and an artifact anyone can brute-force is found by whoever owns the most compute rather than by whoever went looking. `seal()` refuses under 128 bits.
Who holds the salt?
You do, with the secret, wherever you keep things that must outlive a laptop. The record deliberately carries neither, so losing the salt means the artifact can never be opened — which is the honest consequence of a commitment that reveals nothing.
The licence
Apache-2.0, read from the package’s own manifest. Embed it in anything, including closed software — that is what makes a spec adoptable and a verifier worth running. FlashyOS’s server side is AGPL-3.0-only instead, and a test in the monorepo asserts the direction between them: AGPL code may consume this, this may never consume AGPL code.
Keep reading
Also in proof