Usage

Read the registry from R, pin it by commit SHA, and project it into the compact config shape

The registry’s canonical source is a set of annual JSON sidecars under metadata/; the amrr R package is the supported way to consume them. Everything on this catalog — this page included — is derived from those sidecars.

Read a record

Point amrr at a registry checkout and read one cell (jurisdiction × system × year). Accountability achievement_targets are re-merged onto the assessment record at read time, and the resolved commit SHA pins the exact bytes your analysis used — record it so any past run is reconstructable.

If you don’t pass registry=, amrr resolves it from options(amrr.registry=), then the AMRR_REGISTRY environment variable, then by auto-discovery — walking up from the working directory to the nearest checkout (a directory with both metadata/ and schemas/). So starting R anywhere inside a clone just works; set options(amrr.registry = "/path/to/checkout") in your .Rprofile for a machine-wide default.

# install.packages("r-pkg/amrr", repos = NULL, type = "source")   # or devtools::load_all("r-pkg/amrr")
library(amrr)

# No registry= needed when R runs inside a checkout (equivalent to registry = ".").
md  <- get_metadata("IN", system = "ilearn", year = 2024)
rec <- md[[1]]
amrr_registry_ref(md)                       # commit SHA — record this with your run

amrr_cutscores(rec, "ELA")                  # enrolled grade -> level lower bounds
amrr_achievement_levels(rec, "ELA")$proficient_from   # "At Proficiency"
amrr_enrollment(rec, "ELA")                 # $intended_enrollment_grade "fixed" + enrolled grades
amrr_targets(rec, "ELA")                    # proficiency target, merged from accountability

amrr_registry_ref() returns the commit SHA of the checkout; passing ref = to get_metadata() resolves against that exact commit.

Reproducible remote — pin by commit SHA, no checkout

registry also accepts a GitHub repo: get_metadata() reads the canonical Tier A sidecars straight from GitHub pinned to an exact commit SHA (via the git-trees + raw-content APIs), so a remote read is byte-for-byte reconstructable without a local checkout. ref (a SHA, branch, or tag) is resolved to a concrete commit SHA and recorded as the pin. An optional token (AMRR_GITHUB_TOKEN / GITHUB_PAT / GITHUB_TOKEN) raises the GitHub API rate limit; installing the curl package is recommended.

repo <- "github://CenterForAssessment/assessment-metadata-registry"
md   <- get_metadata("IN", system = "ilearn", year = 2024, registry = repo, ref = "b824b20")
amrr_registry_ref(md)                       # the resolved 40-hex commit SHA — the pin

Read over HTTP (convenience, latest build)

registry also accepts a plain URL — point it at this published catalog and get_metadata() fetches the jurisdiction bundle (…/dist/<jurisdiction>.json) over HTTP internally, no checkout required. Unlike the github:// form this serves the latest build only (the derived layer isn’t retained per SHA), so use it for convenience and the github:// remote (or a checkout at a SHA) when you need a reproducible pin.

pages <- "https://centerforassessment.github.io/assessment-metadata-registry"
md <- get_metadata("IN", system = "ilearn", year = 2024, registry = pages)
amrr_registry_ref(md)                       # the SHA the published build was derived from

The derived JSON is also just fetchable directly — dist/**, index.json, config/**, changelog.json, manifest.json all resolve under the catalog URL for any HTTP client.

The compact config view

Omit year to get every year for a system as an amrr_metadata set, then project it into the compact assessment-config authoring shape — reusable named level schemes, tests, a content_area × grade → test map, and unified {loss, hoss, values} cuts. read_config() expands it back into a record, so authoring can happen in whichever shape is more convenient.

cfg <- as_config(get_metadata("IN", system = "ilearn", registry = "."))
names(cfg$level_schemes)                    # "general_4" — one scheme, shared by ELA + Math
cfg$tests$ela$intended_enrollment_grade     # "fixed" (the axis a bare grade list can't carry)
back <- read_config(cfg)                     # -> an amr.assessment.v2 record

See the Config view page for every program rendered in this shape, and the spec for the full field-by-field schema.

Validate & build locally

For authoring and derivation, the whole toolchain is R behind a Makefile:

make setup       # once: install the R tooling + site packages
make validate    # Tier A gate — schema + registry invariants (or: Rscript -e 'amrr::validate_registry(".")')
make build       # validate, then derive Tier B into build/
make site        # render this catalog into site/_site/
make all         # validate -> build -> R tests

CI runs the same validate on every PR; build-publish regenerates and deploys this catalog on merge to main.