Skip to content

Releases

causet v0.31.0

causet v0.31.0 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 16 Nov 04:58
  • Experimental: import writes the fact log, and cst provenance and
    cst receipts read it
    (#419, ADR-0047 decisions 5–8). In a native
    repository:

    • Import reads the history of refs/notes/causet into the fact log's
      shared chain, with one entry per notes commit (store type 09). Each
      entry adds the facts its notes tree gives that are not current at its
      parents, and retires those it no longer gives. Its actor and time come
      from the notes commit's committer line.
    • A fact (store type 08) is a record import can take, in canonical
      JSON. Its object IDs are the native IDs of what they name, at the fields
      its family's published schema marks.
    • Parked facts. A note import cannot read, a record it cannot take
      and a repeated copy are kept as parked facts, which no reader is
      handed. Records it cannot take include those of an unknown version,
      invalid ones, and those naming objects the store lacks or holding a
      fraction, as every reconciliation's timings do.
    • Roots. The commits records name, such as a landing's absorbed
      commits, get native commits too.
    • cst fsck checks every fact and entry: a fact's record is
      canonical, and its names are its object IDs and its subject. An entry
      keeps the log's rules of parents, scope, adds and retires.
    • cst provenance [<revision>] [--all] and cst receipts, with and
      without --json, answer as they answer in the Git-backed original, IDs
      translated, and start no Git process. cst provenance declare is
      refused.

    Recording a fact changes no native commit's ID. Until the operation log
    holds them (#423), a chain's heads are the entries no other names as a
    parent. The local chain of disputed copies and dispositions, the legacy
    refs/notes/vcs-lab name, and cst metadata status and validate are
    #420's. docs/native-history/facts.md is the contract, and
    native/model now lists each note-record family's object-ID fields, held
    to the published schemas by a test. Like every native command, all of this
    needs CAUSET_EXPERIMENTAL=native and is not a contract.

causet v0.30.0

causet v0.30.0 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 15 Nov 23:47
  • Experimental: cst branch and cst tag list a native repository's
    names
    (#418, ADR-0047 decisions 9 and 12). Import's ref snapshot now
    becomes names:

    • refs/heads/* become branches, refs/tags/* tags and refs/remotes/*
      read-only remote-tracking names;
    • a symbolic ref names a name when its target is in one of those three
      namespaces, as origin/HEAD names origin/main;
    • cst's records (refs/notes/causet, refs/causet/*, refs/vcs-lab/*)
      and every other ref, refs/stash and refs/replace/* among them, stay in
      the snapshot for the bridge and are never shown as names.

    In a native repository, cst branch lists the branches, -r the
    remote-tracking names and -a both, and cst tag the tags. -l and
    --list take patterns matched as Git's ref-filter matches them, *
    crossing /.

    • --format prints byte for byte what git branch --format and
      git tag --format print on the Git-backed original, IDs translated, for
      every field cst for-each-ref implements. %(HEAD) is refused, since a
      native repository's HEAD is no name.
    • Without --format both print cst's own listing, a name a line and a
      symbolic one as alias -> main. With --json they print the new
      causet.names/v1 document.
    • Refused: creating, moving, copying or deleting a branch or tag, which
      the operation log and native writes bring (#423, #426); Git's other
      options, such as -v, --sort and --contains; -r or -a given a
      name. Each has a registered code, and under --json is the failure
      envelope.

    Neither command starts a Git process. docs/native-history/operations.md
    §2.3 is their contract, including where Git cannot be matched: a detached
    HEAD's line, and a symbolic ref to a ref that is no name. cst log's
    decorations (%d, %D, %S, %(decorate), %(describe)) stay refused;
    #455 tracks them. Like every native command, all of this needs
    CAUSET_EXPERIMENTAL=native and is not a contract.

causet v0.29.0

causet v0.29.0 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 15 Nov 12:41
  • Experimental: cst log and cst show read native history the way Git
    reads it
    (#417, ADR-0046 decision 2, ADR-0047 decision 12). In a native
    repository:

    • --format prints byte for byte what git log --format and git show -s --format print on the Git-backed original, IDs translated. That holds
      for every placeholder a native commit's own fields answer:

      • every author and committer form, %ad in each implemented --date
        mode;
      • %B %f %e %x, %m, and %(trailers) with all its options;
      • the %+, %- and space prefixes, padding, truncation and %w()
        wrapping;
      • %C colours, printed as Git prints them off a terminal: as nothing.

      Non-UTF-8 and malformed commits print exactly. A placeholder whose source
      native history does not hold yet is refused before anything prints:

      • decorations, which wait on names (#418);
      • %N, which waits on facts (#419);
      • the reflog, Git signatures and the mailmap;
      • human dates and %C(always,…).
    • cst log walks as Git's revision walk does, newest first. It takes
      <rev>, ^<rev> and <a>..<b>, a range marked as Git's limit_list
      marks it, and -n, --skip, --reverse, --first-parent, --merges,
      --no-merges and --date.

    • cst show prints commits and annotated tags, a tag of a tag down to
      its commit, each commit once.

    • Without --format both print cst's own human output, with each
      commit's change identity, lineage and actors. With --json they print the
      new causet.log/v1 and causet.show/v1 documents.

    • Refused:

      • show --format without -s, since Git would follow it with a patch;
      • a patch, paths, a...b, and Git's named formats such as --oneline;
      • every other option.

      Each is refused with a registered code, and under --json as the failure
      envelope.

    Import now also writes a native tag, store type 07, straight after each
    annotated tag a name reaches, and a later import adds the ones a store from
    an earlier build lacks. cst fsck re-derives each imported tag. Every
    native command names an annotated tag by its native tag, as it names a
    commit by its native commit. docs/native-history/reading.md is the new
    contract for both commands, including the few places Git itself cannot be
    matched. Like every native command, all of this needs
    CAUSET_EXPERIMENTAL=native and is not a contract.

causet v0.28.1

causet v0.28.1 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 14 Nov 22:26
  • cst's records are read through one record source (#415). cst provenance, cst receipts, cst graph and cst metadata status and
    validate now take their records from a single source. In a Git-backed
    repository that source is the notes, as before. This prepares a native
    repository to answer the same commands from its fact log (#419, #420;
    ADR-0047), without any reader's parsing, validation or output changing.
    Nothing changes for cst: every suite mode, the conformance fixtures and
    the frozen oracle answers pass unchanged.

causet v0.28.0

causet v0.28.0 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 14 Nov 18:33
  • Provenance says whether an actor is a human or an agent, and whom an
    agent acts for
    (#414, ADR-0047 decision 3). A causet.provenance/v1
    actor takes two optional members: kind, human or agent, and for,
    the human or organisation an agent acts for, present only with kind
    agent. cst provenance declare <commit> --kind agent --for <actor>
    states them, and --kind human states the other kind. A kind describes
    one actor, so the declaration must name exactly one, CAUSET_AGENT
    included. Otherwise it is refused with usage-conflicting-options, as is
    --for with --kind human. An unknown kind or an empty --for is
    usage-invalid-option-value, and --for without --kind is
    usage-missing-argument. cst commit does not take them. cst provenance
    shows them after the actor as (human), (agent) or (agent for <actor>),
    and its JSON reports them in actors. A record without them validates and
    reads exactly as before, and an absent kind means the kind is unstated.
    The record model refuses any other kind, and any for that is not a
    non-empty string with kind agent. The published schema records the
    addition, and so does docs/schemas/compatibility.md, in a new section on
    members added inside a version. Provenance carried through a hard squash,
    cherry-pick, reconcile or rebase keeps both. Where the carried sources
    disagree about one actor's kind or principal, the carried actor leaves that
    member out, whatever order the sources come in. A build older than this one
    drops both members when it carries provenance. The record it carried from
    keeps them. cst --help lists the new flags.

causet v0.27.2

causet v0.27.2 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 13 Nov 21:16
  • npm is published by hand with scripts/publish-npm.ps1 (#448). While
    npm/cli#9969 keeps automatic npm publishing off (#139), a maintainer runs
    pwsh -File scripts/publish-npm.ps1 -Version <x.y.z> after npm login. It
    publishes the release's own tarballs from its GitHub release, never a
    checkout. It refuses a tarball whose digest is not the one SHA256SUMS
    lists, and a main package that does not pin both platform packages at the
    version. A main package published from a checkout would install without
    cst. It publishes the platform packages first, then the main package,
    skips any version npm already has (so a rerun is safe), and takes
    -DryRun. It needs PowerShell 7. Nothing changes for cst or its
    packages.

causet v0.27.1

causet v0.27.1 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 13 Nov 19:23
  • ADR-0048 is accepted (#440). Every landing releases a version of its
    own, and one dispatch of promote.yml makes a version the stable release.
    The owner accepted it after v0.26.0, v0.26.1 and v0.27.0 released
    themselves on landing and v0.27.0 became the stable release that way. This
    documents a decision and changes no behavior.

causet v0.27.0

Choose a tag to compare

@github-actions github-actions released this 13 Nov 14:34
  • Node.js 24 is the new floor (#445). Node 20 reached end of life on
    2026-04-30. The npm package now declares engines.node >=24, so
    installing cst through npm, running its launcher when install scripts did
    not run, and developing from a checkout all need Node.js 24 or newer. The
    installed cst still needs no Node.js, and install.sh and install.ps1
    are unchanged. CI runs every suite on Node 26, the active LTS, and a full
    qualification also runs the default and session-on modes on Node 24, the
    floor. The suites' store reader dropped its fallback for a Node that cannot
    read zstd. That fallback mistranslated a commit a later import adds, and it
    failed the 0.26.1 promotion on Node 20.

causet v0.26.1

causet v0.26.1 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 13 Nov 04:22
  • /what-next puts an active handoff first. When handoff_map.json
    names one for this repository, the report leads with it and recommends
    /lets-go, and one whose document has not reached this machine is shown
    as pending. It still changes nothing, and a machine without the handoffs
    config skips the check.

causet v0.26.0

causet v0.26.0 Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 13 Nov 03:11

Every landing is a version, and native repositories arrive. This is the
first version a landing released by itself (ADR-0048); a later one becomes
the stable release by one dispatch. Since 0.25.1, experimental native
repositories have come in: cst import copies a Git repository's whole
history into N1's content store (ADR-0045), losslessly, verifiably,
deterministically and incrementally; a native repository answers Git's
inspection commands itself; and it has a history of its own that cst log
reads (N2, ADR-0047). The suites gained reftable, SHA-256 and native-kind
modes, and corpora of generated histories and real repositories.

  • Every landing is a version, and one dispatch makes a version stable
    (#440, ADR-0048). When ci.yml passes on a push to main, release.yml
    tags the landing with the version its newest changelog section names,
    builds and installs that version, and publishes it as a GitHub prerelease.
    The install scripts keep installing the stable release, and
    install.sh --version <x.y.z> reaches any landing's build.
    gh workflow run promote.yml -f version=<x.y.z> runs the whole release
    gate on that version's tag and, when every gate passes, makes its GitHub
    release the latest. npm takes part in both, under next and then
    latest, once the repository variable NPM_PUBLISH is true; while
    npm/cli#9969 blocks publishing from CI (#139), npm is published by hand. A pull request's newest
    changelog section must now name the version its merge will mint, which a
    new changelog job checks, and package.json on main names the release
    line: a release build writes its own version into it. The hand release
    procedure, its preparation branch and its draft releases are gone.

  • N1's storage gate counts N1's objects, and native history's bytes are
    reported beside it
    (#437). Since #416, import has written a native
    commit for each commit a name reaches. Native commits are N2's objects, but
    they counted against N1's storage gate (ADR-0044 item 2, release gate 11),
    and git/git's store, 126,093,364 bytes, failed against Git's 113,030,000.
    ADR-0044 is amended: a phase's storage gate counts its own objects and its
    predecessors', and a later phase's objects are reported, never gated,
    until that phase exits. What native history may cost against Git is
    decided at N2's exit. The real-repository check now gates an import
    written without native history, through a test-only hook,
    CAUSET_TEST_IMPORT_WITHOUT_HISTORY=1, and each job's summary gains a row
    for the bytes native history adds, never checked. corpora.yml also runs
    for a pull request that touches the native import, store or history
    crates, since only the corpora measure what a store holds. No behavior of
    cst changes.

  • Experimental: a native repository names each commit by its native
    commit, in every command
    (#435). cst rev-parse, cat-file, ls-tree,
    for-each-ref and import's HEAD is at line now print a commit's native
    commit ID wherever import derived one, as cst log does, and take that
    ID, a unique prefix of it, or the commit's Git ID. cat-file shows a
    native commit as Git shows the commit: -t prints commit, -s and
    --batch give its Git bytes, and -p names its tree and parents by their
    native IDs. The preserved Git commit a native commit derives from is no
    longer an object to any command: its ID and its prefixes name nothing. A
    commit with no native commit keeps its preserved ID: a carrier such as a
    notes commit, a commit only refs/stash or a similar ref reaches, and
    every commit of a store imported before #416. cst log's %h and a
    prefix are unique among the same objects, so every %h resolves in every
    command. A new option, cst rev-parse --git-id, prints the Git ID of what
    each revision names. A command that prints a commit ID now reads the
    store's every index once, about 60 ms on an import of this repository,
    and also reads every native commit once when it meets a commit that has
    none, such as a notes or stash commit. docs/native-history/commits.md §6 records the rules.
    Like every native command, all of this needs CAUSET_EXPERIMENTAL=native
    and is not a contract.

  • Experimental: a native repository has history, and cst log reads it
    (#416), the first slice of N2 (ADR-0047). Import now also writes a native
    commit, store type 06 of docs/native-history/commits.md, straight after
    each Git commit that a branch, a tag or a remote-tracking ref reaches:

    • its tree and parents, as native objects;
    • its author and committer;
    • its message's encoding, and the message byte for byte;
    • an authored actor from its author line;
    • its Change-Id, Derived-From and Origin-Commit, lifted as
      Git-backed cst lifts them.

    A carrier commit, such as a notes commit, gets none. A later import gives
    one to a commit a name reaches only by then. In a native repository,
    cst log [<revision>] --format=<format> prints a revision's history in
    Git's order, byte for byte with git log --format on the original, with
    native commit IDs, and runs no Git. Its placeholders are
    %H %h %T %t %P %p %an %ae %ad %cn %ce %cd %s %b %n %%. Every other
    option and placeholder, paths, and a message in an encoding other than
    UTF-8 or ISO-8859-1 are refused. cst fsck also checks each native commit,
    re-deriving an imported one from the Git commit it came from. A store
    imported before this change has no native commits, and cst log asks for
    it to be imported again. Like every native command, all of this needs
    CAUSET_EXPERIMENTAL=native and is not a contract.

  • The generated-history corpus runs weekly on a new seed, without
    blocking anything
    (#336). corpora.yml checks only the seed
    causet-n1, kept fixed so release gate 11 fails the same way twice, and a
    fixed seed finds nothing new once it passes. A new workflow,
    rotating-corpus.yml, checks 1,000 histories of the ISO week's seed
    (weekly-<year>-W<week>) on Ubuntu and Windows every Thursday, and on
    manual dispatch with an optional seed. It gates nothing, and corpora.yml,
    its seed and gate 11 are unchanged. A failure turns the run red, and its
    last job, the only one allowed to write issues, opens one needs-triage
    issue per seed. The issue lists each failing host and history with its
    problems, the command that reproduces it, and the run's link. A later
    failure of that seed comments on the seed's issue instead, reopening it if
    it was closed. To file it, the corpus test writes a JSON report when
    CAUSET_GENERATED_REPORT names a file. No behavior of cst changes.

  • Experimental: import holds the commits, tags and trees it reads on disk,
    not in memory
    (#405). Since #347, git/git's import peaked at 3.1 GB,
    most of it the Git bytes of every commit, tag and tree import reads before
    it encodes them. Import now writes each object's bytes to a file named
    import.objects as it reads them, keeps only where each one sits, and
    reads them back from that file, never from Git again. The file follows
    import.metadata: it sits in .cst-import/ for a new store and beside
    import.lock for an existing one, and is removed before the store is put
    in place and on every failure. The next import replaces one a killed import
    left, and no command reads it. An import therefore needs more temporary
    disk while it runs: on git/git about 2.6 GB more, about 4.2 GB with the
    held metadata. The store it writes is byte-identical to before, and the
    format is unchanged. The import report (CAUSET_TEST_IMPORT_REPORT) gains
    heldObjects, the file's peak size, and each real repository's job summary
    in corpora.yml gains a column for it. Both are reported, never checked.

  • The incremental import check compares every delta both imports store
    (#338). The import checks hold an incremental import to what a full import
    of the same history holds, and since ADR-0045's amendment of 2026-10-26
    they let a large version be a delta in one and a chunk list in the other.
    When both stored a version as a delta, nothing compared the two records.
    Now the check requires the same record in both, byte for byte. Its base is
    fixed by history, the same path in the introducing commit's first parent
    (storage.md §5.1), and its data by the contract's parameters and the pinned
    zstd (§7). A delta is alone in a stored frame, so the check reads both
    records with no decompression, on every Node the suites support, and never
    skips. It fails on a delta in any other frame, and on a difference, naming
    the version and both bases, or its base and the first byte where the
    records differ. The generated-history corpus and each real repository's
    job summary say how many deltas it compared: 223 across the 1,000
    generated histories. No behavior of cst changes.

  • Experimental: importing git/git peaks at half the memory, and each real
    repository's job summary says what its imports cost
    (#347). A full
    import of git/git on Linux peaked at 6.3 GB, nearly all of it while import
    read every commit, tag and tree: it held one name for every tree entry Git
    follows, across a whole round, before it dropped the duplicates, and most
    entries name objects already read. Import now drops each duplicate as it
    reads it, so the peak is 3.1 GB, set now by the trees' and commits' bytes
    held until they are encoded. Import asks Git for the same objects in the
    same order as before, and the store it writes is byte-identical. Set
    CAUSET_TEST_IMPORT_REPORT to a file and cst import writes there what
    it cost, as JSON:

    • seconds in all and for each of its seven phases;
    • the process's peak memory in all and as each phase ends, on Linux only,
      and null elsewhere, since every crate forbids unsafe code;
    • the peak size of the held metadata it spills to disk while it writes.

    The variable is a test hook, ine...

Read more