I've spent a long career mostly in security. I like to see problems and figure out how to solve them.
The problem I've been chasing lately isn't access control - we're actually pretty good at that. It's what happens after access is granted. Can I prove that the thing that just committed to a database, pushed to production, or triggered a payment is the exact same thing that was reviewed and approved? As systems get more complex - more middleware, more serialization boundaries, more agents acting on their behalf - that question gets harder to answer. At my level of abstraction, and in between.
I needed something at the protocol layer. A stable fingerprint for structured data that I could attach authorization and verification to at higher layers. But once I started building it, I realized the same primitive could solve problems all the way down the stack. A developer might fingerprint a deployment descriptor at approval time and verify it hasn't drifted by the time it hits the deployment controller. An infrastructure team can hand an auditor a fingerprint that proves exactly what was committed, not just that something was committed. If you've ever had to prove "this is the same thing" across a system boundary, you have some version of this problem.
The issue underneath is deceptively simple. The same logical payload produces different hashes when different systems serialize it differently. Field ordering changes, whitespace shifts, encoding varies. Two identical payloads suddenly look like two different objects to any integrity check.
MAP is my answer. It canonicalizes structured data into a deterministic binary format and produces a single identity: map1: + lowercase hex SHA-256 of the canonical bytes. Same input, same identity. Every time. Every language.
What's in the box:
- Frozen spec (483 lines, no changes permitted under governance contract)
- Python and Node reference implementations (zero dependencies each)
- 53 conformance vectors (append-only, never removed)
- Both implementations produce identical MIDs for all inputs
Supported types: strings (UTF-8, scalar-only), maps (sorted keys, unique, memcmp ordering), lists, and raw bytes. No numbers. No nulls. These are rejected deterministically, not silently coerced.
Early. No Go or Rust implementations yet. The no-numbers decision is opinionated and I know it. Curious what people think, and if you've hit this problem in your own work, how you've been solving it.
I've spent a long career mostly in security. I like to see problems and figure out how to solve them.
The problem I've been chasing lately isn't access control - we're actually pretty good at that. It's what happens after access is granted. Can I prove that the thing that just committed to a database, pushed to production, or triggered a payment is the exact same thing that was reviewed and approved? As systems get more complex - more middleware, more serialization boundaries, more agents acting on their behalf - that question gets harder to answer. At my level of abstraction, and in between.
I needed something at the protocol layer. A stable fingerprint for structured data that I could attach authorization and verification to at higher layers. But once I started building it, I realized the same primitive could solve problems all the way down the stack. A developer might fingerprint a deployment descriptor at approval time and verify it hasn't drifted by the time it hits the deployment controller. An infrastructure team can hand an auditor a fingerprint that proves exactly what was committed, not just that something was committed. If you've ever had to prove "this is the same thing" across a system boundary, you have some version of this problem.
The issue underneath is deceptively simple. The same logical payload produces different hashes when different systems serialize it differently. Field ordering changes, whitespace shifts, encoding varies. Two identical payloads suddenly look like two different objects to any integrity check.
MAP is my answer. It canonicalizes structured data into a deterministic binary format and produces a single identity: map1: + lowercase hex SHA-256 of the canonical bytes. Same input, same identity. Every time. Every language.
What's in the box:
- Frozen spec (483 lines, no changes permitted under governance contract)
- Python and Node reference implementations (zero dependencies each)
- 53 conformance vectors (append-only, never removed)
- Both implementations produce identical MIDs for all inputs
- CLI tools for both languages
- Browser playground: https://map-protocol.github.io/map1/
- MIT licensed
Supported types: strings (UTF-8, scalar-only), maps (sorted keys, unique, memcmp ordering), lists, and raw bytes. No numbers. No nulls. These are rejected deterministically, not silently coerced.
Early. No Go or Rust implementations yet. The no-numbers decision is opinionated and I know it. Curious what people think, and if you've hit this problem in your own work, how you've been solving it.