What you meant is what runs

From an interface to a call the owner confirms

Two layers, one job. The interface layer says what a call's values are; the profile layer says what they mean.

1. 01

   Compile

   The .did becomes a validated Contract graph with an interface_id.

2. 02

   Describe

   A profile bound to that id says what each value means and what each call does.

3. 03

   Generate

   Agent tools, consent messages and formatters come from the resolved profile.

4. 04

   Confirm

   The owner approves the exact call. Retries cannot pay twice.

One transfer, start to finish

An ICRC-1 transfer of 1.5 ICP, from the interface to the result. The interface, the annotation and the consent message are real: the first two are files in the repository, and the message is what @meantjs/consent returns for this transfer with the ICRC-1 pack. The JavaScript is compiled against the package's declarations when the site is built.

1. The interface says what the values are
   candidprofile/packages/consent/test/fixtures/ledger.didcopy

   type TransferArg = record {
     from_subaccount : opt Subaccount;
     to : Account;
     amount : Tokens;
     fee : opt Tokens;
     memo : opt blob;
     created_at_time : opt Timestamp
   };
   // …
   icrc1_transfer : (TransferArg) -> (TransferResult);

   The interface says amount : nat. It does not say that the ledger counts in units of 10^-8, that created_at_time makes a retry safe, or that Err.Duplicate means the payment already went through. The meant compiler turns the interface into a Contract graph whose identity moves only when the callable interface does; the ICRC-1 standard's fragment has this one:

   interface_idcandid-core:interface:v1:sha256:7fae0dd330b20f53ae1e4e2cb1947c1c57791da0ae20299ceb499f63228d0689Copy

2. A profile says what they mean
   jsonprofile/packs/icrc1.profile.jsoncopy

   {
     "at": "icrc1_transfer(0).amount",
     "tag": "amount",
     "args": {
       "decimals": {
         "from": "query:icrc1_decimals"
       },
       "symbol": {
         "from": "query:icrc1_symbol"
       }
     }
   },

   A profile is a separate document bound to that identity. Each annotation names one position in the interface and attaches a tag to it. This one, from the ICRC-1 pack, says the transfer's amount is a token amount whose decimals and symbol the ledger reports itself. The pack carries 29 such annotations, and applies to any ledger whose interface is a subtype of the standard's.

3. The agent writes what a person would
   The model sees1.5 ICP

   send_tokens({
     to: "ig6pt-…-ig6",
     amount: "1.5 ICP"
   })

   exact, no rounding

   The call sends150000000

   icrc1_transfer(record {
     amount = 150_000_000;
     created_at_time = opt 1_793_059_200_000_000_000;
     …
   })

   jscopy

   import { parseAmount } from "@meantjs/format";
   
   parseAmount("1.5 ICP", { decimals: 8, symbol: "ICP" }); // "150000000"
   parseAmount("1.123456789", { decimals: 8 }); // throws E_EXCESS_PRECISION: never rounded

   An agent writes amounts the way a person does. The tool layer converts them exactly, fills the defaults, stamps created_at_time once per intent and keeps it out of the model's hands, and refuses rather than rounds.

4. The owner reads what the call does
   Consent · ICRC-21

   Send tokens

   transferirreversible

   Amount

   1.5 ICP

   Recipient

   ig6pt-bilfj-…-4ysgf-ig6

   RejectConfirmOnly the owner confirms. The model never does.
   jsoncopy

   { "FieldsDisplayMessage": {
       "intent": "Send tokens: Send 1.5 ICP to ig6pt-bilfj-ewrb5-gyxsa-gisbm-b7z5p-o47mn-dswdx-s225j-4ysgf-ig6",
       "fields": [
         ["Amount", { "TokenAmount": { "decimals": 8, "amount": "150000000", "symbol": "ICP" } }],
         ["Recipient", { "Text": { "content": "ig6pt-bilfj-ewrb5-gyxsa-gisbm-b7z5p-o47mn-dswdx-s225j-4ysgf-ig6" } }]
       ] } }

   The same profile writes the ICRC-21 consent message for the call, for any method, not only icrc1_transfer. Calls whose effect is transfer, approve, admin or destroy wait for the owner's confirmation, unless a policy the owner set allows them: for a transfer or an approval, that can be terms the owner confirmed for the task. The model never confirms.

5. Every result has a class

   Result case of icrc1_transfer	Class	What the caller does
   Ok	success	Report it done.
   Err.Duplicate	already_done	Report the earlier block. Never pay again.
   Err.TemporarilyUnavailable	retry_same	Resend the same encoded bytes.
   Err.TooOld, Err.CreatedInFuture	retry_new	Stamp again, and ask the person to confirm again.
   Err.BadFee, Err.BadBurn	fix_input	Show the hint and ask for a corrected value.
   Err.InsufficientFunds, Err.GenericError, anything else	fail	Stop. Do not retry.
   A timeout, then TooOld	reconcile	Check the ledger's history for the first attempt before anything else.

   Every result case has a class, so the caller knows whether to stop, fix the input, retry with the same bytes, or find out whether the first attempt already went through.

Two layers

Interfaces Interface graphs and identities

The meant crate compiles a Candid interface through the official checker into a canonical, validated graph with content-addressed identities. @candid-core/schema gives TypeScript typed schemas, validation and a binary codec from the same graph.

Profiles Profiles: what each value means

The Candid Profile spec, its standard packs, and the @meantjs packages that resolve profiles and generate tools, consent and formatting from them. meant-format does the amount tag in Rust.

What you can build on it

Profiles Give an agent a canister's tools

Input in human units, a preview the person confirms before every send, and retries that cannot pay twice.

Profiles Consent messages for any method

ICRC-21 messages, both forms, from a resolved profile and the encoded arguments, in a browser, in Node, or inside the canister.

Profiles Show and read values exactly

Amounts, times, durations, accounts, subaccounts and bytes, parsed and shown by one rule that refuses excess precision rather than rounding it.

Interfaces Tell whether an interface actually changed

Compare one string. Renamed types, reordered fields and comments leave interface_id where it was; a changed argument type moves it.

Interfaces Encode and decode Candid in TypeScript

A schema-directed implementation of the wire format with no runtime dependencies, which returns issues instead of throwing.

Interfaces Accept .did source you did not write

Every entry point is bounded: over-limit input comes back as a structured diagnostic rather than exhausting memory, CPU or the stack.

What is published

One repository, B3Pay/Meant. The crates and the two package families version independently, and everything is pre-1.0.

Chains

Meant was built on the Internet Computer. Most of the profile spec does not depend on the chain, and a binding per chain covers what does.

Start where you are

Profiles Profile a token ledger

Check the ICRC-1 pack against a ledger's interface and convert an amount exactly.

Interfaces Typed, validated canister values

Install @candid-core/schema, describe an interface, validate a value and encode it, with no Rust toolchain.

Interfaces Compile a .did to a Contract

One dependency line and one call give you a validated graph with identities you can compare and cache on.

Evaluating it What is actually proven

The verification gates, the cross-implementation evidence, and what is still pending.