MALT v0.0.8 — Faster Root-Bound Map Proofs

MALT Core v0.0.8 reduces Map proof latency by eliminating one redundant root-bound opening per visited radix node.

Highlights

• Map.Prove loads each visited radix node once.
• The requested ProveSlot opening authenticates the node root and is reused for traversal instead of performing an additional slot-zero opening.
• Regression coverage requires one ProveAtRoot call per visited node.

Compatibility and security boundary

KZG, IPA, and fallback proof paths remain root-bound and fail closed. This release does not alter roots, CIDs, commitment parameters, commitments, proofs, transcripts, ProofLists, schemas, receipts, or wire encodings.

Source

• Tag: v0.0.8
• Commit: 6c55430
• Previous authoritative tag: v0.0.7
• Merged change: #195

Validation

• Full Go tests passed on the exact final merge commit.
• 32-bit KZG and IPA commitment tests passed.
• Verifier WASM Resolve/Read and Map-proof conformance passed for all, KZG, and IPA targets.
• Writer WASM smoke passed for KZG plus IPA direct, compact, and fast profiles.
• Full go vet and go build passed.
• GitHub Go and CodeQL checks passed on the final merge commit.
• Release assets were built twice under different ambient Go settings and umasks; every byte matched.
• Both asset sets passed checksum, archive/provenance, and adversarial ustar validation.

Asset checksums

The attached SHA256SUMS file binds the two archives and the release manifest. Its SHA-256 is f197396f2ccbd270c8324530b4a4923955d2a4a2e1a282ccd49a8ab8edff64cc.

MALT Core v0.0.7

Release date: 2026-08-17

This is the first stable Core release from DeWebProtocol/malt-core. MALT
remains pre-v1 and experimental.

Release Contract

The source tag is the authoritative release artifact. This release publishes:

• the Go module at github.com/dewebprotocol/malt-core;
• structured typed MALT roots in the private-use 0x30VSBB codec layout;
• the malt.resolve/v0alpha1, malt.read/v0alpha1, and
  malt.map-proof/v0alpha1 verification profiles;
• the experimental client-root profiles documented in
  Client-Root Contract;
• the frozen Resolve/Read conformance corpus v1 for structured version-2 roots;
• the frozen Resolve/Read conformance corpus v2 for version-3 roots;
• the frozen Map-proof conformance corpus v1 for KZG and IPA membership,
  non-membership, and adversarial rejection;
• the frozen client-root conformance corpus v1 for exact KZG and IPA candidate
  computation and fail-closed inputs; and
• reproducible, content-addressed browser Verifier and Writer asset sets.

Split Writer assets use malt.web-writer.provenance/v3, which binds their
profiles and Core-enforced runtime invariants without asserting host device
selection or retry policy.

MALTVersionID=3 is a wire-format version, not the source release version.

Changes Since v0.0.7-rc.5

Core repository and module namespace

The application-neutral SDK repository moved from DeWebProtocol/malt to
DeWebProtocol/malt-core. Its Go module path is now
github.com/dewebprotocol/malt-core; downstream source imports must migrate to
that path and pin v0.0.7.

All earlier Core commits, tags, GitHub Releases, and release assets remain
unchanged in DeWebProtocol/malt-core. No historical tag was deleted,
retracted, moved, or recreated. See the
repository migration notice for old-path and
runtime-namespace implications.

The namespace migration does not alter roots, CIDs, commitment parameters,
commitments, proofs, transcripts, ProofLists, receipts, existing protocol
schemas, existing Resolve/Read conformance vectors, or wire encodings relative
to v0.0.7-rc.5. Final v0.0.7 adds dedicated Map-proof and client-root corpus
envelopes, schemas, and vectors without changing their enclosed wire profiles.
The release WASM assets are rebuilt from the renamed module and bind the new
repository, module, commit, corpus digests, and checksums in their provenance.

Final language-neutral conformance corpora

The checked-in malt.map-proof.conformance/v1 corpus covers KZG and IPA Map
membership, non-membership, proof tampering, cross-root relabeling, wrong-key
requests, target tampering, and strict JSON rejection. The checked-in
malt.client-root.conformance/v1 corpus binds complete update views and
semantic intents to exact candidate bundles, materializations, next views, and
sample operational receipts, with stale-base, view-tamper, wrong-backend, and
strict JSON rejection cases.

Go and browser/WASM tests consume the same frozen JSON bytes. The conformance
profile names version corpus envelopes; they do not change the enclosed wire
profile identifiers. Client-root candidates and receipts remain operational
outcomes, not portable transition, publication, freshness, or trust proofs.

Changes Since v0.0.7-rc.4

Authenticated Writer session checkpoints

The SDK Writer can now seal a verified session checkpoint using a caller-owned
32-byte key. The checkpoint authenticates the normalized update view, every
working root, and a caller-supplied digest of the materializer bytes. A valid
checkpoint restores the verified session state without recomputing every
complete vector.

The in-memory ArcSet materializer now supports deterministic detached state
export and strict restoration. Restore rejects duplicate scopes, roots, paths,
conflicting targets, invalid CIDs, and missing or multiply owned node paths.

Checkpoint persistence and key protection remain trusted-client policy. The
caller must restore the exact materializer bytes bound by the authenticated
digest before restoring a session. Cache misses, corrupt state, or unavailable
keys must fall back to normal Session.Load verification. A checkpoint is a
local execution cache, not a portable transition, publication, freshness, or
trust proof.

This SDK addition does not alter roots, CIDs, commitment parameters,
commitments, proofs, transcripts, ProofLists, receipts, schemas, or wire
encodings.

Changes Since v0.0.7-rc.3 Through v0.0.7-rc.4

Batched Map Writer commitments

The graph Writer now converts all canonical changes for one Map object into a
single semantic BatchUpdate. The radix implementation opens and validates
the existing top-level node once, applies affected subtree changes in
batch-local state, and computes and persists one final top-level commitment
after every change succeeds.

Input ordering is preserved, including multiple changes below the same root
slot. Tests require the batched result to match sequential updates exactly and
require one final top-level commitment for a multi-arc batch.

This optimization removes repeated top-level KZG or IPA commitment work from
multi-arc Writer transactions. It is an execution optimization, not an
aggregated proof or a new transition-proof contract. It does not alter roots,
CIDs, commitment parameters, commitments, proofs, transcripts, ProofLists,
receipts, schemas, or wire encodings.

Changes Since v0.0.7-rc.2 Through v0.0.7-rc.3

Fast KZG verifier initialization

Portable and browser verifiers now construct a verification-only KZG scheme.
It loads the canonical G1 generator and the first two G2 opening-key points,
without parsing or retaining the 4096-point Writer commitment key. The final
Verifier WASM does not link the 393,216-byte preprocessed Writer setup asset.

Fast KZG Writer initialization

KZG Writers now decode build-time validated canonical Lagrange G1 coordinates
instead of parsing the upstream JSON setup and decompressing 4096 points at
runtime. Both compact assets are derived from the exact pinned
go-kzg-4844 v1.1.0 setup. Generation enforces the upstream setup SHA-256,
performs full curve and subgroup validation, and emits asset fingerprints.

A reconstruction test repeats that derivation and byte-compares the committed
assets. Compatibility tests use unique values in every KZG slot and compare
commitments and openings at multiple bit patterns against the pinned upstream
implementation.

The rc.3 delta changes KZG setup loading and internal commitment, opening, and
verification execution while preserving externally observable parameters and
encodings. It does not alter roots, CIDs, commitments, proofs, transcripts,
ProofLists, receipts, schemas, or wire encodings.

Changes Since v0.0.7-rc.1 Through v0.0.7-rc.2

Separate Verifier and Writer runtimes

The browser Verifier no longer initializes Writer-only commitment state or IPA
fixed-base committer tables. Writer functionality is published as one KZG
module and three IPA modules using the direct, compact, and fast
committer profiles. Applications can load the Verifier independently and
initialize a Writer only when local mutation is required.

All IPA profiles preserve the same parameter set, commitments, typed roots,
transcripts, proofs, and wire formats. Profile selection never changes an IPA
operation into KZG.

Hardened Writer lifecycle

The browser Writer controller now provides lazy backend/profile
initialization, cancellation-safe startup, explicit single-runtime ownership,
exact backend/profile targeting, observable idle Worker failures, and
fail-closed retirement of fatal runtimes. Failed stateful operations are not
automatically replayed against a replacement runtime. Selecting a profile from
device signals or retrying another profile remains host policy.

Content-addressed WASM delivery

Verifier and Writer files are published as coordinated asset sets. Each set is
identified by the full SHA-256 digest of its exact SHA256SUMS bytes. Release
archive filenames bind both the extracted asset-set digest and the exact
compressed archive digest:

malt-verifier-v0.0.7-<asset-set-sha256>-<archive-sha256>.tar.gz
malt-writer-v0.0.7-<asset-set-sha256>-<archive-sha256>.tar.gz

Only complete digest paths are immutable. Consumers must load every file in a
runtime from one asset set, must not mix digests, and must reload when the
application entrypoint selects a new digest. The full contract is documented
in WASM Release Assets.

Protocol Baseline From v0.0.7-rc.1

Structured typed roots: 0x30VSBB

Typed MALT root codecs now use the project private-use 0x30VSBB layout, where
V identifies the wire version, S the semantic kind, and BB the commitment
backend suite. New constructors emit these version-3 codecs:

Semantic kind	KZG	IPA
Map	0x303101	0x303102
List	0x303201	0x303202

Decoders fail closed on unknown versions, semantics, backend suites,
combinations, identity-hash sizes, and mixed-profile children. Structured
version-2 roots remain readable and verifiable, but default constructors do not
emit them.

4096-slot KZG semantic geometry

KZG Map and List nodes now use all 4096 commitment positions. KZG Maps consume
SHA-256 keys as 12-bit radix digits. KZG Lists reserve position zero for
authenticated metadata and expose 4095 content positions. IPA remains a
256-position suite, using 8-bit Map digits and 255 List content positions.

The same backend-sized geometry is used by semantic producers,
materialization, and portable verification.

Verifiable Map non-membership

The new Map-proof contract verifies both membership and non-membership for KZG
and IPA roots. An exact absent keyed relation can be authenticated by:

• a proved empty radix slot;
• a conflicting terminal leaf; or
• a complete fixed-domain collision bucket.

Ve...

MALT v0.0.7-rc.5 — Authenticated Writer Session Checkpoints

MALT v0.0.7-rc.5 adds authenticated local Writer session checkpoints for trusted clients.

Highlights

• The in-memory ArcSet materializer can export deterministic detached state and restore it with strict structural validation.
• A Writer session checkpoint authenticates the normalized update view, complete working roots, and caller-supplied materialization digest with a caller-owned 32-byte key.
• A valid checkpoint restores verified local session state without recomputing every complete vector.
• Cache misses, corrupt materialization, or unavailable keys must fall back to normal Session.Load verification.

Compatibility and security boundary

Checkpoints are trusted-client local execution caches. They are not portable transition, publication, freshness, or trust proofs. The client owns persistence, key protection, and verification that restored materializer bytes match the authenticated digest.

This release does not alter MALT roots, CIDs, commitment parameters, commitments, proofs, transcripts, ProofLists, receipts, schemas, or wire encodings. The v0.0.7 release-candidate line remains pre-v1 and wire-incompatible with the flat v0.0.6 root codecs.

Source

• Tag: v0.0.7-rc.5
• Commit: 4364d188ba2fcff8111fee2801e7408a582511c0
• Previous authoritative tag: v0.0.7-rc.4

Validation

• Full Go tests, 32-bit KZG/IPA tests, vet, and SDK builds passed locally and in GitHub Actions.
• Verifier WASM Resolve/Read and Map-proof conformance passed for all, KZG, and IPA targets.
• Writer WASM controller and stateless/session smoke passed for KZG plus IPA direct, compact, and fast profiles.
• A temporary external module compiled public root, protocol, SDK verifier, and materializer imports.
• GitHub PR #193 passed Go CI and CodeQL.
• Independent release review reported no actionable findings.
• Release assets were built twice from the exact tagged commit under different ambient Go settings and umasks; every byte matched.
• Both asset sets passed checksum, archive/provenance, and adversarial ustar validation.

Asset checksums

66fbc837e8555ce50a86a011501fa9862e35e8fe682b54122890e30eb9c5ace0  malt-verifier-v0.0.7-rc.5-9cea0a30c601adc8bb0cd6de3027ca75d0fc8f3a22ff375397fc537e85967640-66fbc837e8555ce50a86a011501fa9862e35e8fe682b54122890e30eb9c5ace0.tar.gz
c7f6f724204471398342d6d882aa2a61ed79b6034569cd2fd29fe234a9b2315b  malt-writer-v0.0.7-rc.5-2404727fd7bacd2a6295fd90b0a230958c517e471b7aca62e4e9b4e702029b80-c7f6f724204471398342d6d882aa2a61ed79b6034569cd2fd29fe234a9b2315b.tar.gz
9a80628d28ff561cc4235a262e173044994c7cf640466a31fb97eafd0bb5b4a1  malt-wasm-release-v0.0.7-rc.5-9a80628d28ff561cc4235a262e173044994c7cf640466a31fb97eafd0bb5b4a1.json
4a57cc176d816478f8c79b0cd5cf61d3e6bcefb3650fc767973bd01096dc0350  SHA256SUMS

MALT v0.0.7-rc.4 — Batched Map Writer Commitments

MALT v0.0.7-rc.4 reduces Writer latency for transactions that change multiple Map arcs by computing one final top-level commitment.

Highlights

• The graph Writer sends canonical changes for one Map object through one semantic BatchUpdate.
• The radix Map opens and validates the existing top-level node once, applies subtree changes in batch-local state, and persists one final top-level commitment.
• Ordered changes below the same root slot are preserved.
• Batched final roots are byte-for-byte identical to sequential updates.

Compatibility

This is an execution optimization, not an aggregated proof or a portable transition-proof contract. It does not alter MALT roots, CIDs, commitment parameters, commitments, proofs, transcripts, ProofLists, receipts, schemas, or wire encodings.

The v0.0.7 release-candidate line remains pre-v1 and wire-incompatible with the flat v0.0.6 root codecs. See the source release notes for the full rc.1 through rc.4 compatibility contract.

Source

• Tag: v0.0.7-rc.4
• Commit: 761680066f78d24c16701f7e48f9c1579d64d981
• Previous authoritative tag: v0.0.7-rc.3

Validation

• Full Go tests, 32-bit KZG/IPA tests, vet, and SDK builds passed.
• Verifier WASM Resolve/Read and Map-proof conformance passed for all, KZG, and IPA targets.
• Writer WASM controller and stateless/session smoke passed for KZG plus IPA direct, compact, and fast profiles.
• A temporary external module compiled the public root, protocol, SDK verifier, and materializer imports.
• GitHub PR #191 passed Go CI and CodeQL.
• Independent release review reported no actionable findings.
• Release assets were built twice from the exact tagged commit under different ambient Go settings and umasks; every byte matched.
• Both asset sets passed checksum, archive/provenance, and adversarial ustar validation.

Asset checksums

6dc29088f2934054c885ae88121703e52f35576f7c5c7c6797c40a0152a693f4  malt-verifier-v0.0.7-rc.4-6dbd11bd78b44bff25debd5ac04694ebb229351fda423b0b316a72289995181f-6dc29088f2934054c885ae88121703e52f35576f7c5c7c6797c40a0152a693f4.tar.gz
a203d766277e39ccf8c92017190bf6aad43baff502a0b7d963b7883a597dd183  malt-writer-v0.0.7-rc.4-8dd4298b6a83570566156fa7146eaacd1d028454e6bdc149d974eecb7e1650b5-a203d766277e39ccf8c92017190bf6aad43baff502a0b7d963b7883a597dd183.tar.gz
673f69c4266604f6728fc47d8862bb4b2d6c40b4a2df4a28ebabf16952698859  malt-wasm-release-v0.0.7-rc.4-673f69c4266604f6728fc47d8862bb4b2d6c40b4a2df4a28ebabf16952698859.json
5e62b77d86affc64d7cfbed52592dd7201d89a236356c96d2f2529249cceafc9  SHA256SUMS

MALT v0.0.7-rc.3 — Fast KZG Verifier and Writer Initialization

MALT v0.0.7-rc.3 removes the remaining KZG setup bottleneck and optimizes the
internal commitment, opening, and verification path while preserving external
commitment and wire semantics.

Highlights:

• Verifier-only KZG initialization loads only the canonical G1 generator and
  two retained G2 opening-key points.
• KZG Writer startup uses build-time validated canonical coordinates instead
  of runtime JSON parsing and decompression of 4096 G1 points.
• Generated setup assets are derived from the pinned go-kzg-4844 v1.1.0
  setup; reconstruction validates all 4096 retained G1 points and both retained
  G2 points, then byte-compares committed assets.
• Compatibility tests compare commitments, openings, claimed scalars, and
  bidirectional verification with the pinned upstream implementation across
  multiple bit patterns.

Compatibility:

• No changes to MALT roots, CIDs, KZG parameters, commitments, proofs,
  transcripts, ProofLists, receipts, schemas, or wire encodings.
• The v0.0.7 line remains experimental and pre-v1. v0.0.6 flat roots still
  require rebuilding as documented in the release notes.

Release source:

• Commit: 02943b24f6506d7c14d7f7fc952065aaa9e0abaa
• Previous authoritative tag: v0.0.7-rc.2
• Go module: github.com/dewebprotocol/malt@v0.0.7-rc.3

Validation:

• full Go test, vet, and build
• 32-bit KZG and IPA tests
• Verifier WASM all/KZG/IPA vectors
• Writer WASM KZG and all IPA profile smoke tests
• external public-package consumer build
• two complete release builds under different ambient Go environments and
  umasks were byte-identical
• release checker passed; seven noncanonical ustar variants were rejected

Published asset SHA-256:

• verifier archive: 2fe6b11634951a7b76be56da6c57104fadf5cac95816492098b58addb7292684
• writer archive: 9e7692ef6959114901ac678478455e24096262c8dc4408b62e075eac302e6ce7
• release manifest: 6e89938898593fc32479fdbc51aa19b5e14af753bc7e1fbd39d9d850b43bddd1
• top-level SHA256SUMS: e1a49ef0407dacd016f419e8e618f23218fe880a33fd8a056225b37a5b427754

Source tags are authoritative. The attached WASM bundles are reproducible,
content-addressed convenience assets with exact provenance.

MALT v0.0.7-rc.2 — Verifier/Writer Separation and Content-Addressed WASM Delivery

This release candidate completes the browser Verifier/Writer separation
introduced in v0.0.7-rc.1 and establishes a reproducible, content-addressed
WASM delivery contract.

MALT remains pre-v1, experimental, and not production-ready.

Highlights

Separate Verifier and Writer runtimes

The browser Verifier no longer initializes Writer-only commitment state or IPA
fixed-base committer tables. Writer functionality is published as one KZG
module and three IPA modules using the direct, compact, and fast
committer profiles.

All IPA profiles preserve the same parameter set, commitments, typed roots,
transcripts, proofs, and wire formats. Core requires an explicit exact
backend/profile; device selection and retrying another profile remain host
policy.

Hardened Writer lifecycle

The Writer controller provides lazy initialization, cancellation-safe startup,
one runtime per controller, exact backend/profile targeting, observable idle
Worker failures, and fail-closed retirement of fatal runtimes. Failed stateful
operations are not automatically replayed against a replacement runtime.

Content-addressed WASM assets

Verifier and Writer files are published as coordinated sets. Each asset set is
identified by the full SHA-256 digest of its exact SHA256SUMS bytes. Archive
filenames additionally bind the SHA-256 of the exact compressed archive.

Only complete digest paths are immutable. Consumers must load every runtime
file from one asset set and must not mix files from different digests.

The Writer bundle uses malt.web-writer.provenance/v3, which binds split
artifacts and Core-enforced runtime invariants without asserting host device
selection or retry behavior.

Compatibility

This RC does not change MALT roots, CIDs, parameter sets, transcripts,
commitments, proof encodings, ProofLists, receipts, or serialized protocol
profiles relative to v0.0.7-rc.1.

Browser integrations built against rc.1 must adopt the split Writer filenames,
the createMaltWriterWorker controller API, and Writer provenance v3.

The v0.0.7 line remains an intentional pre-v1 source- and wire-breaking change
relative to v0.0.6. The structured 0x30VSBB roots, 4096-slot KZG geometry,
Map membership/non-membership proofs, and client-root contracts introduced in
rc.1 remain experimental.

See the complete release notes and WASM asset contract.

Release contract

• Authoritative source tag: v0.0.7-rc.2
• Tagged commit: 80a6dc86e35815e3d4201adfbecf949caca21c42
• Toolchain: Go 1.25.7
• Convenience assets: Verifier archive, Writer archive, release manifest, and
  top-level SHA256SUMS

Release assets are immutable and must not be renamed or replaced.

Validation

• Exact-commit Go release gate and CodeQL checks passed.
• Full Go test, vet, and build gates passed locally and in CI.
• 32-bit KZG and IPA commitment tests passed.
• Verifier WASM passed 49 Resolve/Read plus 8 Map-proof vectors with both
  backends, and 25 plus 4 vectors in each backend-selected run.
• Writer controller tests passed 12/12; KZG and all three IPA Writer profiles
  passed their WASM/session tests and Worker smoke.
• A temporary external Go module compiled against the tagged tree.
• Two builds under different ambient Go environments and umasks produced
  byte-identical release assets.
• Canonical gzip/ustar, provenance, checksums, archive members, metadata,
  padding, and end-block validation passed.
• Seven self-consistent but noncanonical archive variants were rejected.

Published checksums

b152ed22cefeb80928ced636896635f18e6bb407d472125bb8c2bb688cfe6d4d  malt-verifier-v0.0.7-rc.2-d12a6cd24aded6a0f371f87d4067eadd360a5da4ef6e7736dfd5654ec406fb3f-b152ed22cefeb80928ced636896635f18e6bb407d472125bb8c2bb688cfe6d4d.tar.gz
87dd6eaa703ef3690505d64aa514175e54ce7e06b08d084ebcf1fcde46c14019  malt-writer-v0.0.7-rc.2-0e7b6506ffc9f446a6bf7f42649632c3f42a7520d0a827f2ee95d11ba67ae12a-87dd6eaa703ef3690505d64aa514175e54ce7e06b08d084ebcf1fcde46c14019.tar.gz
d3f5b2c8d67429842b9f84e9b23e273a2895f3bb41777ba0ae5c5f6f9e188407  malt-wasm-release-v0.0.7-rc.2-d3f5b2c8d67429842b9f84e9b23e273a2895f3bb41777ba0ae5c5f6f9e188407.json

Known limits

• The browser Verifier is the Go verifier compiled to WebAssembly, not an
  independent cryptographic implementation.
• Core does not select Writer profiles from browser capability hints or retry a
  different profile after failure; applications define that host policy.
• Running clients must reload after the application entrypoint selects a new
  Verifier or Writer asset-set digest.
• Client-root bundles and materialization receipts are not portable
  state-transition, publication, freshness, or trust proofs.

MALT v0.0.7-rc.1

This is a prerelease for integration and verifier testing. MALT remains pre-v1, experimental, and not production-ready.

Release contract

The source tag is the authoritative release artifact. This candidate publishes:

• the Go module at github.com/dewebprotocol/malt;
• structured typed MALT roots in the private-use 0x30VSBB codec layout;
• the malt.resolve/v0alpha1, malt.read/v0alpha1, and malt.map-proof/v0alpha1 verification profiles;
• the experimental client-root profiles documented in the Client-Root Contract;
• the frozen Resolve/Read conformance corpus v1 for structured version-2 roots; and
• the frozen Resolve/Read conformance corpus v2 for version-3 roots.

MALTVersionID=3 is a wire-format version, not the source release version.

Highlights

Structured typed roots: 0x30VSBB

Typed MALT root codecs now use the project private-use 0x30VSBB layout, where V identifies the wire version, S the semantic kind, and BB the commitment backend suite. New constructors emit these version-3 codecs:

Semantic kind	KZG	IPA
Map	0x303101	0x303102
List	0x303201	0x303202

Decoders fail closed on unknown versions, semantics, backend suites, combinations, identity-hash sizes, and mixed-profile children. Structured version-2 roots remain readable and verifiable, but default constructors do not emit them.

4096-slot KZG semantic geometry

KZG Map and List nodes now use all 4096 commitment positions. KZG Maps consume SHA-256 keys as 12-bit radix digits. KZG Lists reserve position zero for authenticated metadata and expose 4095 content positions. IPA remains a 256-position suite, using 8-bit Map digits and 255 List content positions.

The same backend-sized geometry is used by semantic producers, materialization, and portable verification.

Verifiable Map non-membership

The new Map-proof contract verifies both membership and non-membership for KZG and IPA roots. An exact absent keyed relation can be authenticated by:

• a proved empty radix slot;
• a conflicting terminal leaf; or
• a complete fixed-domain collision bucket.

Version-3 collision buckets authenticate their empty tail positions, enabling sound collision-bucket non-membership. This release adds MapProofRequest, MapProofResult, MapProver, VerifyMapProof, the malt.map-proof/v0alpha1 schemas, the terminal ProofList step map_absence, and the matching Go SDK and browser/WASM verification boundary.

Other changes

• Add deterministic Resolve/Read conformance corpora for KZG and IPA.
• Add complete-view client-root values, sdk/writer, exact candidate-root bundles, root-bound Map materialization witnesses, and receipt-gated writer sessions.
• Add a unified browser writer WASM with isolated KZG and IPA workers.
• Add request-scoped read and writer observations for diagnostics.
• Narrow materializer and graph-writer dependencies to the capabilities used by each algorithm.
• Rebuild a verified structured-version-2 complete view as version 3 before applying client-side changes.
• Reject incomplete List materialization, noncanonical Map-proof coordinates, target relabeling, invalid UTF-8, stale intents, mismatched receipts, and mixed backend/version materialization.
• Remove radix.ProveTimings, (*radix.Map).ProveWithTimings, the obsolete process-global logger package, the former graph/querypath helper, and the unused zap and multierr dependencies.

Compatibility

This is an intentional pre-v1 source- and wire-breaking release candidate.

v0.0.6 emitted the flat experimental codecs 0x300001 through 0x300004. The current decoder intentionally does not classify those roots as structured MALT roots. This release does not provide a flat-root migration layer; experimental roots and their materialized proof-serving state should be recreated.

Structured version-2 roots (0x302...) were introduced on main after v0.0.6 and are not v0.0.6 roots. They remain available for read, proof, and exact complete-view replay. New constructors emit version 3, and collision-bucket non-membership requires the version-3 fixed-domain bucket profile.

Removed Go APIs have no forwarding compatibility shims. The /v1 suffixes on client-root profiles version serialized experimental profiles; they do not declare MALT or its Go APIs stable at v1.

Known limits

• Non-membership proves only whether one exact keyed relation is absent from a Map. It does not prove List-index, graph-path, object, payload-byte, or remote data absence.
• Ordinary Read keeps its existing missing-key result, ErrQueryNotFound; there is no corresponding List non-membership API.
• Collision-bucket non-membership is available only for version-3 fixed-domain buckets.
• The browser/WASM verifier is the same Go verifier compiled for WebAssembly, not an independent cryptographic implementation.
• Client-root bundles and materialization receipts are not portable state-transition, publication, freshness, or trust proofs.

Validation

• Tagged commit: a4799c63d167a2ca361c84967f6484bff3bf5471
• Exact-commit CI: Go / Test and vet, Push on main, and Code Quality all succeeded.
• Local release-range, formatting, full Go test, 32-bit KZG/IPA, vet, and build gates passed on the tagged commit.
• Verifier WASM passed 49 Resolve/Read plus 8 Map-proof vectors with both backends, and 25 plus 4 vectors in each KZG-only and IPA-only run.
• Writer WASM passed KZG and IPA stateless/session smoke tests plus the dual-Worker smoke test.
• A temporary external Go module compiled against the tagged tree while importing the module-root malt, protocol, sdk/verifier, and auth/arcset/materializer packages.

This is a source-only release. No binary or WASM assets are attached; consumers build from source.

MALT v0.0.6

MALT v0.0.6

Release date: 2026-07-14

v0.0.6 establishes DeWebProtocol/malt as an SDK-only core. It keeps the
protocol, commitment, proof, semantic, mutation, execution, and verifier
building blocks required by clients and gateways, while removing product and
application implementations from the module.

Boundary changes

Core retains:

• module-root resolve/read/query and verification values;
• malt.resolve/v0alpha1 and malt.read/v0alpha1 schemas;
• ProofList, KZG/IPA, typed CID, map/list semantics, resolver/writer algorithms;
• portable mutation/receipt values and untrusted execution.Executor;
• local Go/WASM verifier surfaces;
• the frozen malt.artifact/v0alpha2 compatibility verifier.

Core removes:

• cmd/malt, cmd/cas, cmd/eval;
• daemon, config, HTTP API/server, reference executor;
• CAS/KV adapters and concrete ArcTable implementations;
• UnixFS model/client/runtime packages;
• evaluator plans, commands, and schemas.

DeWebProtocol/gateway now owns persistent ArcTable/KV/CAS and generic
resolve/read/apply service execution. DeWebProtocol/malt-client owns the
trusted CLI/daemon, accepted roots, UnixFS planning, local verification, and
payload-byte binding. Web remains a browser client using the WASM verifier.

ArcSet capability

Proof-generation algorithms accept auth/arcset/materializer.Store. This is a
narrow algorithmic capability over ArcSet views and commitment nodes, not an
ArcTable implementation or persistence contract. A small in-memory
implementation remains for conformance tests and examples.

Compatibility

This is an intentional pre-v1 source-breaking release. There are no forwarding
packages for removed product/application paths. The serialized resolve/read
profiles, ProofList format, typed root codecs, and frozen artifact profile are
not revised by this release.

Validation checklist

• git diff --check
• gofmt clean
• go test ./...
• go vet ./...
• go build -buildvcs=false ./...
• native and WASM verifier builds
• external consumer compile against the SDK packages
• gateway and malt-client full test/vet suites
• Web test and production build

The GitHub release identifies the exact tag commit and final validation result.

Documentation erratum

After publication, PR #166 corrected SECURITY.md to identify v0.0.6 as the current supported experimental release and aligned its scope with the SDK-only core boundary. The immutable v0.0.6 tag remains at 841c22415a54810006d6640a24c54566b6ba3f39.

MALT v0.0.5 — Resolve/Read Client Boundary

MALT v0.0.5

Status: released on 2026-07-13

MALT v0.0.5 tightens the boundary between the portable authentication core,
trusted clients, untrusted gateway/executor work, immutable CAS payloads, and
application models such as UnixFS. It is an experimental source release, not a
stable API line or production managed service.

Release Contract

• Go module: github.com/dewebprotocol/malt@v0.0.5
• resolve profile: malt.resolve/v0alpha1
• primitive-read profile: malt.read/v0alpha1
• frozen compatibility profile: malt.artifact/v0alpha2
• schemas: protocol/schemas/*.schema.json
• reference routes:
  • POST /v1/resolve
  • POST /v1/read
  • POST /v1/verify/resolve (diagnostic only)
  • POST /v1/verify/read (diagnostic only)

Highlights

• The module-root malt package exposes application-neutral
  ResolveRequest/ResolveResult and typed primitive-read contracts together
  with portable VerifyResolve and VerifyRead functions.
• execution.Executor performs untrusted resolve/read/apply work over injected
  resolver, semantic prover, and mutation-applier capabilities. It never makes
  the client trust decision.
• protocol publishes operation-specific request, result, verification, and
  JSON Schema contracts. ProofList is evidence carried by those results, not a
  generic operation envelope.
• mutation owns namespace-free semantic mutation, delta, commit-descriptor,
  and write-receipt values. Receipts and candidate roots are not cryptographic
  state-transition proofs.
• UnixFS is split across model/unixfs, sdk/unixfs, and runtime/unixfs so
  application semantics, client planning/body verification, and reference
  execution are not treated as MALT core.
• sdk/verifier, malt verify, and the browser/WASM build bind a
  caller-selected request to an untrusted result before portable ProofList
  verification.
• The process managed by malt start is documented as an all-in-one reference
  executor. Remote verify routes are diagnostic/conformance helpers, not trust
  authorities.

Resolution And Payload Semantics

Clients submit canonical segment arrays without discovering authenticated arc
boundaries. Resolution authenticates one complete returned derivation and does
not claim longest-prefix maximality, uniqueness, or application preference.

An empty segment array is strict root identity. Payload selection uses the
explicit reserved @payload segment. A verified payload resolve authenticates
a CID; clients must additionally bind returned full or ranged bytes to that CID
using ordinary CID verification or sdk/unixfs.VerifyRangeBody as appropriate.

Compatibility

The v0.0.4 malt.artifact/v0alpha2 resolve/prove/verify operation set remains
frozen. New integrations should use malt.resolve/v0alpha1 and
malt.read/v0alpha1 rather than adding operations to that compatibility
profile.

This release intentionally removes the former layout/unixfs Go package path.
Consumers should import the model, SDK, or runtime package matching their role.
All current profiles and Go APIs remain experimental before v1.0.0.

Security Boundary

Resolvers, ArcTable indexes, gateways, caches, CAS availability, and reference
execution are untrusted for correctness. Clients accept results only after
local verification against an explicit trusted root and caller-constructed
request. Root freshness, authority, rollback prevention, tenant policy, and
multi-writer arbitration remain application or managed-gateway concerns.

Validation Gate

The release commit is validated with:

git diff --check
gofmt -l .
go test ./...
go vet ./...
go build -buildvcs=false ./...
scripts/build-verifier-wasm.sh dist/verifier
bin/malt-eval run --plan examples/eval-smoke-plan.json --run-id v0.0.5-smoke

Additional gates cover an external consumer of the root facade and protocol
schemas, native and WASM builds, local verifier accept/tamper rejection, and
gateway/Web integration against the exact release source.

Published Tags

• v0.0.5-rc.1: validated candidate source tag
• v0.0.5: final experimental source release

Both tags identify the same approved source tree. Source tags are authoritative;
native binaries remain build-from-source. Published browser verifier artifacts
must identify their exact MALT source commit and SHA-256 checksum.

Related Documents

• MIP-1013: Client, Gateway, And Core Responsibility Boundary
• Resolve and read contracts
• Frozen artifact compatibility profile
• Compatibility policy
• Release process

MALT v0.0.4

MALT v0.0.4 publishes canonical segment-path composition and the transport-neutral malt.artifact/v0alpha2 contract for resolve, primitive prove, and verify.

Highlights:

• immutable SegmentPath API with / as the canonical textual projection
• proof-carrying multi-arc resolution without a longest-or-unique verifier claim
• unversioned Go artifact package with embedded JSON Schemas and conformance fixtures
• stable /v1/artifacts/{resolve,prove,verify} reference endpoints
• gateway/web product smoke covering upload, resolve, prove, verify, content read, and tamper rejection

See docs/releases/v0.0.4.md for the contract and validation boundary.