Help us shape the future of Go! Take the 2026 Go Developer Survey

axx

module
v0.2.24 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 29, 2026 License: Apache-2.0

README

BLACK, BOX, MEET and AXX in ASCII, smashed into an ASCII axe

axx

axx ("axxeptance") is the open-source behavioral verification layer for agentic software factories: an acceptance testing framework that verifies running software against executable acceptance criteria, black-box, independent of the language, architecture or agent that built it.

Let agents build it. Prove that it works.

Using axx? Everything is at axx.nimbusxr.us: installing it, the guides, and every step.

Work on axx

You need mise, and Docker for the integration tests.

git clone https://github.com/nimbusxr/axx && cd axx
mise install                    # Go and the tools, at the versions the repository pins
go build -o bin/axx ./cmd/axx   # axx
mise run test                   # go test -race ./...
mise run lint
mise run generate               # after changing steps, config or schemas; generated files are committed
  • AGENTS.md: where things are, and the rules every change follows.
  • CONTRIBUTING.md: sign off each commit (git commit -s), and title pull requests as conventional commits.
  • Security issues: SECURITY.md.

Apache-2.0, © NimbusXR.

Directories

Path Synopsis
Package app runs the axx command line.
 Package app runs the axx command line.
cmd
axx command
Command axx runs executable acceptance criteria as black-box tests against running software.
 Command axx runs executable acceptance criteria as black-box tests against running software.
Package core is the public API for axx step packs.
 Package core is the public API for axx step packs.
internal
agents
Package agents connects coding agents to axx: it finds the agents a project uses and adds the axx MCP server to the configuration they read, merged into what is there, never replacing it.
 Package agents connects coding agents to axx: it finds the agents a project uses and adds the axx MCP server to the configuration they read, merged into what is there, never replacing it.
avrojson
Package avrojson reads and writes Avro values the way the Apache Avro Java library does, for the steps and tools that exchange Avro data with people: payload files written in Avro's JSON encoding, and assertions over the text Java printed for a record.
 Package avrojson reads and writes Avro values the way the Apache Avro Java library does, for the steps and tools that exchange Avro data with people: payload files written in Avro's JSON encoding, and assertions over the text Java printed for a record.
axxerr
Package axxerr provides axx's structured error type.
 Package axxerr provides axx's structured error type.
check
Package check matches the steps of parsed feature files against a step registry and reports every step that cannot run: undefined, ambiguous, or given the wrong argument.
 Package check matches the steps of parsed feature files against a step registry and reports every step that cannot run: undefined, ambiguous, or given the wrong argument.
cli
Package cli wires axx's command-line interface.
 Package cli wires axx's command-line interface.
cloudstep
Package cloudstep holds what the cloud service packs share: waiting for something the services under test do asynchronously, matching rows, items, documents and messages against a step's table with the text comparison of the other packs' JSON property steps, and reading seed files.
 Package cloudstep holds what the cloud service packs share: waiting for something the services under test do asynchronously, matching rows, items, documents and messages against a step's table with the text comparison of the other packs' JSON property steps, and reading seed files.
cloudstep/cloudtest
Package cloudtest runs the steps of packs in tests, as a run does: the cloud service packs against local cloud emulators, the web pack against a site the test serves.
 Package cloudtest runs the steps of packs in tests, as a run does: the cloud service packs against local cloud emulators, the web pack against a site the test serves.
compat/internal/oracletest
Package oracletest loads the behavior oracles in testdata/oracles and compares Go results against them.
 Package oracletest loads the behavior oracles in testdata/oracles and compares Go results against them.
compat/javafmt
Package javafmt reproduces how Java renders and parses numbers and values, so text axx produces matches what Java produces for the same value.
 Package javafmt reproduces how Java renders and parses numbers and values, so text axx produces matches what Java produces for the same value.
compat/javare
Package javare implements Java (java.util.regex) regular expressions on top of github.com/dlclark/regexp2, a pure-Go backtracking engine.
 Package javare implements Java (java.util.regex) regular expressions on top of github.com/dlclark/regexp2, a pure-Go backtracking engine.
compat/jsonx
Package jsonx reads, queries and modifies JSON exactly as Jayway JsonPath 2.9.0 does on top of json-smart 2.5.2, in their default configuration.
 Package jsonx reads, queries and modifies JSON exactly as Jayway JsonPath 2.9.0 does on top of json-smart 2.5.2, in their default configuration.
compat/jvalue
Package jvalue holds the value semantics the step packs share: how the text of a feature file becomes typed values, how they are compared, and how values render back to text.
 Package jvalue holds the value semantics the step packs share: how the text of a feature file becomes typed values, how they are compared, and how values render back to text.
compat/jyaml
Package jyaml reads and writes YAML exactly like Jackson's YAML dataformat on top of SnakeYAML.
 Package jyaml reads and writes YAML exactly like Jackson's YAML dataformat on top of SnakeYAML.
config
Package config defines and loads axx.yaml.
 Package config defines and loads axx.yaml.
config/internal/genschema command
Command genschema writes the axx.yaml JSON Schema generated from the Go types.
 Command genschema writes the axx.yaml JSON Schema generated from the Go types.
contract
Package contract is how messaging packs have their messages checked against the contract a registration names, in its asyncapi row, without depending on what checks it: the asyncapi pack provides the checks when a project adds it, and a registration naming a contract without it fails.
 Package contract is how messaging packs have their messages checked against the contract a registration names, in its asyncapi row, without depending on what checks it: the asyncapi pack provides the checks when a project adds it, and a registration naming a contract without it fails.
engine
Package engine assembles configuration, step packs, the match registry and the shared suite.
 Package engine assembles configuration, step packs, the match registry and the shared suite.
exitcode
Package exitcode defines axx's process exit codes.
 Package exitcode defines axx's process exit codes.
feature
Package feature loads Gherkin feature files and compiles them to pickles.
 Package feature loads Gherkin feature files and compiles them to pickles.
filecontent
Package filecontent reads what a file holds, by its type: the text of a plain text, CSV, TSV, JSON, XML, HTML, PDF, Word (.docx) or Excel (.xlsx) file, and the table of a CSV, TSV or Excel file.
 Package filecontent reads what a file holds, by its type: the text of a plain text, CSV, TSV, JSON, XML, HTML, PDF, Word (.docx) or Excel (.xlsx) file, and the table of a CSV, TSV or Excel file.
filelock
Package filelock holds an exclusive lock on a file across processes.
 Package filelock holds an exclusive lock on a file across processes.
fixtures
gotool
Package gotool provides the Go toolchain axx builds itself with when a project lists packs.
 Package gotool provides the Go toolchain axx builds itself with when a project lists packs.
ide
Package ide generates IDE run and debug configurations from axx.yaml, so debugging a service under test is one click in IntelliJ or VS Code.
 Package ide generates IDE run and debug configurations from axx.yaml, so debugging a service under test is one click in IntelliJ or VS Code.
imagediff
Package imagediff compares two images pixel by pixel, as Playwright compares screenshots: pixelmatch's comparison (https://github.com/mapbox/pixelmatch), a color distance in YIQ, with the pixels of anti-aliased edges left out.
 Package imagediff compares two images pixel by pixel, as Playwright compares screenshots: pixelmatch's comparison (https://github.com/mapbox/pixelmatch), a color distance in YIQ, with the pixels of anti-aliased edges left out.
interp
Package interp expands ${prefix:name} references in strings.
 Package interp expands ${prefix:name} references in strings.
jsonassert
Package jsonassert implements the JSON property assertions shared by the packs: JSONPath lookups with Jayway semantics and text comparison of scalars.
 Package jsonassert implements the JSON property assertions shared by the packs: JSONPath lookups with Jayway semantics and text comparison of scalars.
lifecycle
Package lifecycle starts and stops the applications under test.
 Package lifecycle starts and stops the applications under test.
lint
Package lint implements `axx lint`: test-data isolation rules plus builtin feature-file checks.
 Package lint implements `axx lint`: test-data isolation rules plus builtin feature-file checks.
lsp
Package lsp is axx's language server (`axx lsp`).
 Package lsp is axx's language server (`axx lsp`).
match
Package match compiles step definitions into Cucumber expressions and matches step text against them.
 Package match compiles step definitions into Cucumber expressions and matches step text against them.
mcp
Package mcp serves axx to coding agents over the Model Context Protocol (stdio).
 Package mcp serves axx to coding agents over the Model Context Protocol (stdio).
npm
Package npm prepares what packs run with Node.js: a pinned Node.js binary (EnsureNode, WriteNode), and pinned npm packages, from a package-lock.json (Install) or one at a time (Fetch, Unpack).
 Package npm prepares what packs run with Node.js: a pinned Node.js binary (EnsureNode, WriteNode), and pinned npm packages, from a package-lock.json (Install) or one at a time (Fetch, Unpack).
oaslevel
Package oaslevel holds OpenAPI validation levels: the ERROR, WARN, INFO and IGNORE a finding is reported at, the maps from validation keys (validation.request.body.schema.required, ...) to levels, and the keys a validator reports, which levels are set on (Keys).
 Package oaslevel holds OpenAPI validation levels: the ERROR, WARN, INFO and IGNORE a finding is reported at, the maps from validation keys (validation.request.body.schema.required, ...) to levels, and the keys a validator reports, which levels are set on (Keys).
packbuild
Package packbuild builds a copy of axx with a project's packs compiled in, and caches it.
 Package packbuild builds a copy of axx with a project's packs compiled in, and caches it.
packset
Package packset reads and writes axx-packs.yaml, the list of packs a project uses, and axx-packs.lock, which pins the versions of packs that come from Go modules.
 Package packset reads and writes axx-packs.yaml, the list of packs a project uses, and axx-packs.lock, which pins the versions of packs that come from Go modules.
proc
protoload
Package protoload reads protobuf descriptors: .proto files compiled in process, descriptor sets (protoc --descriptor_set_out), and the file descriptors a gRPC server's reflection returns.
 Package protoload reads protobuf descriptors: .proto files compiled in process, descriptor sets (protoc --descriptor_set_out), and the file descriptors a gRPC server's reflection returns.
render/md
Package md renders axx's generated reference documentation as Markdown.
 Package md renders axx's generated reference documentation as Markdown.
report
Package report implements axx's run reporters: human output (pretty, progress), the token-efficient compact and agent formats for coding agents, and the interchange formats CI systems understand (JUnit XML, Cucumber Messages, legacy Cucumber JSON and the Cucumber HTML report).
 Package report implements axx's run reporters: human output (pretty, progress), the token-efficient compact and agent formats for coding agents, and the interchange formats CI systems understand (JUnit XML, Cucumber Messages, legacy Cucumber JSON and the Cucumber HTML report).
runner
Package runner executes pickles against registered step definitions.
 Package runner executes pickles against registered step definitions.
schemadoc
Package schemadoc reads the contract documents that hold JSON Schemas (AsyncAPI, OpenRPC): YAML or JSON, by file or URL, with $refs across documents, the schemas in them compiled where they are, and validation failures keyed by the JSON Schema keyword they break.
 Package schemadoc reads the contract documents that hold JSON Schemas (AsyncAPI, OpenRPC): YAML or JSON, by file or URL, with $refs across documents, the schemas in them compiled where they are, and validation failures keyed by the JSON Schema keyword they break.
secrets
Package secrets keeps a scenario's secrets and masks them.
 Package secrets keeps a scenario's secrets and masks them.
shellwords
Package shellwords splits command lines without a shell, exactly like the original implementation: double-quoted segments become one word (quotes removed); everything else splits on whitespace.
 Package shellwords splits command lines without a shell, exactly like the original implementation: double-quoted segments become one word (quotes removed); everything else splits on whitespace.
signing
Package signing signs HTTP requests the way webhooks are signed, and checks the signatures of the requests a service sent: an HMAC of what a template says (the body, a timestamp, the method, the path) in a header, and Standard Webhooks (https://www.standardwebhooks.com).
 Package signing signs HTTP requests the way webhooks are signed, and checks the signatures of the requests a service sent: an HMAC of what a template says (the body, a timestamp, the method, the path) in a header, and Standard Webhooks (https://www.standardwebhooks.com).
skills
Package skills builds and installs axx's agent skills: hand-written SKILL.md files embedded in the binary plus reference files generated from the step registry at install time (so a project's custom packs are included and nothing can drift).
 Package skills builds and installs axx's agent skills: hand-written SKILL.md files embedded in the binary plus reference files generated from the step registry at install time (so a project's custom packs are included and nothing can drift).
stepsearch
Package stepsearch finds steps by what they do, for `axx steps search` and the MCP server's steps_search: one ranking for both.
 Package stepsearch finds steps by what they do, for `axx steps search` and the MCP server's steps_search: one ranking for both.
stream
Package stream holds the clients of connections a scenario keeps open and reads as things arrive: server-sent event streams and WebSockets.
 Package stream holds the clients of connections a scenario keeps open and reads as things arrive: server-sent event streams and WebSockets.
tablevalue
Package tablevalue builds a JSON object from a step's table of paths and values, for the steps that send one they make from scratch: an operation's variables, a tool's arguments.
 Package tablevalue builds a JSON object from a step's table of paths and values, for the steps that send one they make from scratch: an operation's variables, a tool's arguments.
tokens
Package tokens holds the bearer tokens a scenario registers: JSON Web Tokens axx signs, and OAuth 2.0 client credentials tokens it gets from a token endpoint.
 Package tokens holds the bearer tokens a scenario registers: JSON Web Tokens axx signs, and OAuth 2.0 client credentials tokens it gets from a token endpoint.
tools/axxall command
Command axxall is axx built with every pack axx publishes.
 Command axxall is axx built with every pack axx publishes.
tools/examplestubs
Package examplestubs builds the model stubs the examples' apps ship in their test builds and test deployments, from the stubs of the examples' acceptance projects: `go generate` keeps them up to date, as it does the other generated files.
 Package examplestubs builds the model stubs the examples' apps ship in their test builds and test deployments, from the stubs of the examples' acceptance projects: `go generate` keeps them up to date, as it does the other generated files.
version
Package version reports the build version of axx.
 Package version reports the build version of axx.
packs
a2a
Package a2a is the a2a pack: messages to A2A agents (Agent2Agent protocol) as another agent sends them, over JSON-RPC, HTTP+JSON or gRPC, and their answers: the tasks they run, with their states and artifacts, as they answer or as they stream.
 Package a2a is the a2a pack: messages to A2A agents (Agent2Agent protocol) as another agent sends them, over JSON-RPC, HTTP+JSON or gRPC, and their answers: the tasks they run, with their states and artifacts, as they answer or as they stream.
all
Package all lists every pack axx publishes, by name: for tests and tools that need all of them at once (the step reference, the skills).
 Package all lists every pack axx publishes, by name: for tests and tools that need all of them at once (the step reference, the skills).
amqp
Package amqp is the amqp pack: messages sent to AMQP queues and published to AMQP exchanges, and the messages the services under test send there, over AMQP 0-9-1 (RabbitMQ) or AMQP 1.0 (ActiveMQ Artemis, Qpid).
 Package amqp is the amqp pack: messages sent to AMQP queues and published to AMQP exchanges, and the messages the services under test send there, over AMQP 0-9-1 (RabbitMQ) or AMQP 1.0 (ActiveMQ Artemis, Qpid).
app/core
Package appcore is the app-core pack: the steps every app takes, used as people use it, whatever it runs on (ADR 0012): launched, its controls tapped or clicked and filled, found by the names people see, what it shows checked.
 Package appcore is the app-core pack: the steps every app takes, used as people use it, whatever it runs on (ADR 0012): launched, its controls tapped or clicked and filled, found by the names people see, what it shows checked.
asyncapi
Package asyncapi is the asyncapi pack: the messages a scenario sends, and the messages its checks find, checked against the AsyncAPI document their broker's registration names.
 Package asyncapi is the asyncapi pack: the messages a scenario sends, and the messages its checks find, checked against the AsyncAPI document their broker's registration names.
aws/core
Package awscore is the aws-core pack: the AWS account the aws-* packs talk to, set up as the AWS SDK sets it up for the real services, and the SDK configuration those packs build their clients from.
 Package awscore is the aws-core pack: the AWS account the aws-* packs talk to, set up as the AWS SDK sets it up for the real services, and the SDK configuration those packs build their clients from.
aws/dynamodb
Package awsdynamodb is the aws-dynamodb pack: items seeded into DynamoDB tables and the items the services under test write.
 Package awsdynamodb is the aws-dynamodb pack: items seeded into DynamoDB tables and the items the services under test write.
aws/eventbridge
Package awseventbridge is the aws-eventbridge pack: events put on EventBridge buses and the events the services under test put there.
 Package awseventbridge is the aws-eventbridge pack: events put on EventBridge buses and the events the services under test put there.
aws/internal/queue
Package queue receives messages from SQS queues for the aws-* packs' checks: the queues the services under test write to, and the queues axx subscribes to SNS topics and EventBridge buses for a run.
 Package queue receives messages from SQS queues for the aws-* packs' checks: the queues the services under test write to, and the queues axx subscribes to SNS topics and EventBridge buses for a run.
aws/s3
Package awss3 is the aws-s3 pack: files uploaded to S3 buckets and the objects the services under test write there.
 Package awss3 is the aws-s3 pack: files uploaded to S3 buckets and the objects the services under test write there.
aws/sns
Package awssns is the aws-sns pack: messages published to SNS topics and the messages the services under test publish.
 Package awssns is the aws-sns pack: messages published to SNS topics and the messages the services under test publish.
aws/sqs
Package awssqs is the aws-sqs pack: messages sent to SQS queues and the messages the services under test send to them.
 Package awssqs is the aws-sqs pack: messages sent to SQS queues and the messages the services under test send to them.
azure/blob
Package azureblob is the azure-blob pack: files uploaded to Blob Storage containers and the blobs the services under test write there.
 Package azureblob is the azure-blob pack: files uploaded to Blob Storage containers and the blobs the services under test write there.
azure/servicebus
Package azureservicebus is the azure-servicebus pack: messages sent to Service Bus queues and topics, and the messages the services under test send there.
 Package azureservicebus is the azure-servicebus pack: messages sent to Service Bus queues and topics, and the messages the services under test send there.
cli
Package cli is the cli pack: commands a scenario runs, and what they answer with, their exit code and their output.
 Package cli is the cli pack: commands a scenario runs, and what they answer with, their exit code and their output.
desktop/core
Package desktopcore is the desktop-core pack: the family of app-core's packs that run apps on desktops (ADR 0011, 0012).
 Package desktopcore is the desktop-core pack: the family of app-core's packs that run apps on desktops (ADR 0011, 0012).
desktop/internal/atspi
Package atspi reads and acts on Linux's accessibility tree (AT-SPI), as screen readers do: over D-Bus, in pure Go.
 Package atspi reads and acts on Linux's accessibility tree (AT-SPI), as screen readers do: over D-Bus, in pure Go.
desktop/internal/ax
Package ax reads and acts on macOS's accessibility tree (AX), as screen readers do, without cgo: it calls the ApplicationServices and CoreFoundation frameworks through purego.
 Package ax reads and acts on macOS's accessibility tree (AX), as screen readers do, without cgo: it calls the ApplicationServices and CoreFoundation frameworks through purego.
desktop/internal/desktest
Package desktest is the depot desk's journey (examples/parcels/depot-desk) as the desktop packs' integration tests walk it on each OS, with the packs' steps, as a feature does.
 Package desktest is the depot desk's journey (examples/parcels/depot-desk) as the desktop packs' integration tests walk it on each OS, with the packs' steps, as a feature does.
desktop/internal/jab
Package jab reads and acts on Java apps on Windows through the Java Access Bridge, as Windows screen readers do: Java Swing and AWT windows show UI Automation nothing but their frame.
 Package jab reads and acts on Java apps on Windows through the Java Access Bridge, as Windows screen readers do: Java Swing and AWT windows show UI Automation nothing but their frame.
desktop/internal/uia
desktop/linux
Package desktoplinux is the desktop-linux pack: Linux apps, through AT-SPI, in desktops of axx's own, with the pointer and the keyboard as a person uses them (ADR 0011, 0012).
 Package desktoplinux is the desktop-linux pack: Linux apps, through AT-SPI, in desktops of axx's own, with the pointer and the keyboard as a person uses them (ADR 0011, 0012).
desktop/macos
Package desktopmacos is the desktop-macos pack: macOS apps, through AX, the accessibility tree screen readers read, with the pointer and the keyboard as a person uses them (ADR 0011, 0012).
 Package desktopmacos is the desktop-macos pack: macOS apps, through AX, the accessibility tree screen readers read, with the pointer and the keyboard as a person uses them (ADR 0011, 0012).
desktop/windows
Package desktopwindows is the desktop-windows pack: Windows apps, through UI Automation and, for Java apps, the Java Access Bridge, with the pointer and the keyboard as a person uses them (ADR 0011, 0012).
 Package desktopwindows is the desktop-windows pack: Windows apps, through UI Automation and, for Java apps, the Java Access Bridge, with the pointer and the keyboard as a person uses them (ADR 0011, 0012).
files
Package files is the files pack: the files services and apps write to a folder, such as an export directory, a volume they share with axx, or an app's own data.
 Package files is the files pack: the files services and apps write to a folder, such as an export directory, a volume they share with axx, or an app's own data.
gcp/bigquery
Package gcpbigquery is the gcp-bigquery pack: rows seeded into BigQuery tables and the rows the services under test write.
 Package gcpbigquery is the gcp-bigquery pack: rows seeded into BigQuery tables and the rows the services under test write.
gcp/core
Package gcpcore is the gcp-core pack: the Google Cloud project the gcp-* packs talk to, set up as the Google Cloud client libraries are set up for the real services, and the client options those packs build their clients with.
 Package gcpcore is the gcp-core pack: the Google Cloud project the gcp-* packs talk to, set up as the Google Cloud client libraries are set up for the real services, and the client options those packs build their clients with.
gcp/firestore
Package gcpfirestore is the gcp-firestore pack: documents seeded into Firestore and the documents the services under test write.
 Package gcpfirestore is the gcp-firestore pack: documents seeded into Firestore and the documents the services under test write.
gcp/pubsub
Package gcppubsub is the gcp-pubsub pack: messages published to Pub/Sub topics and the messages the services under test publish.
 Package gcppubsub is the gcp-pubsub pack: messages published to Pub/Sub topics and the messages the services under test publish.
gcp/storage
Package gcpstorage is the gcp-storage pack: files uploaded to Cloud Storage buckets and the objects the services under test write there.
 Package gcpstorage is the gcp-storage pack: files uploaded to Cloud Storage buckets and the objects the services under test write there.
graphql
Package graphql is the graphql pack: queries, mutations and subscriptions to GraphQL services (a federated graph's gateway, or a subgraph alone), their data and errors, checked against the services' schemas.
 Package graphql is the graphql pack: queries, mutations and subscriptions to GraphQL services (a federated graph's gateway, or a subgraph alone), their data and errors, checked against the services' schemas.
grpc
Package grpc is the grpc pack: calls to gRPC services, their status, answers, metadata and streamed messages, read with the services' protos or their reflection.
 Package grpc is the grpc pack: calls to gRPC services, their status, answers, metadata and streamed messages, read with the services' protos or their reflection.
internal/recording
Package recording keeps what a scenario's apps showed as it ran, for the packs that drive apps on a screen (desktop, mobile), as the web pack keeps its pages: a trace, one HTML page with each app's screen after each step; a video, the scenario's screen as it ran with its steps beside it.
 Package recording keeps what a scenario's apps showed as it ran, for the packs that drive apps on a screen (desktop, mobile), as the web pack keeps its pages: a trace, one HTML page with each app's screen after each step; a video, the scenario's screen as it ran with its steps beside it.
internal/video
Package video keeps what a scenario's desktop showed as a video: H.264 in an MP4 file, which plays wherever a video plays.
 Package video keeps what a scenario's desktop showed as a video: H.264 in an MP4 file, which plays wherever a video plays.
jsonrpc
Package jsonrpc is the jsonrpc pack: calls to JSON-RPC 2.0 services over HTTP, their results and errors, checked against the services' OpenRPC documents.
 Package jsonrpc is the jsonrpc pack: calls to JSON-RPC 2.0 services over HTTP, their results and errors, checked against the services' OpenRPC documents.
kafka
Package kafka provides the Kafka steps: services, topic clients (Java client properties translated to franz-go), event drafts published as plain text or Confluent Avro, and consumer assertions over every record of a topic.
 Package kafka provides the Kafka steps: services, topic clients (Java client properties translated to franz-go), event drafts published as plain text or Confluent Avro, and consumer assertions over every record of a topic.
logs
Package logs checks what services logged: a positive way to prove that something did not happen, by asserting the entry that says so ("line ML-KES-0413-1 rejected: duplicate reference").
 Package logs checks what services logged: a positive way to prove that something did not happen, by asserting the entry that says so ("line ML-KES-0413-1 rejected: duplicate reference").
mail
Package mail is the mail pack: the emails the services under test send, read from a mailbox: Mailpit's, through its API, or any mailbox over POP3 or IMAP, a real one included.
 Package mail is the mail pack: the emails the services under test send, read from a mailbox: Mailpit's, through its API, or any mailbox over POP3 or IMAP, a real one included.
mcp
Package mcp is the mcp pack: calls to MCP servers (Model Context Protocol) as an AI assistant makes them, over stdio or streamable HTTP: their tools, with the tools' schemas as the contract, their resources and their prompts.
 Package mcp is the mcp pack: calls to MCP servers (Model Context Protocol) as an AI assistant makes them, over stdio or streamable HTTP: their tools, with the tools' schemas as the contract, their resources and their prompts.
mobile/android
Package mobileandroid is the mobile-android pack: Android apps on emulators and devices, which Appium's UiAutomator2 driver runs.
 Package mobileandroid is the mobile-android pack: Android apps on emulators and devices, which Appium's UiAutomator2 driver runs.
mobile/core
Package mobilecore is the mobile-core pack: native Android and iOS apps, used as people use them.
 Package mobilecore is the mobile-core pack: native Android and iOS apps, used as people use them.
mobile/internal/appium
Package appium is a client of Appium's WebDriver protocol: the W3C WebDriver commands the mobile packs use, and Appium's mobile: commands.
 Package appium is a client of Appium's WebDriver protocol: the W3C WebDriver commands the mobile packs use, and Appium's mobile: commands.
mobile/internal/appium/appiumtest
Package appiumtest is a fake Appium server for the mobile packs' tests: an app of screens, each a page source, which taps move between.
 Package appiumtest is a fake Appium server for the mobile packs' tests: an app of screens, each a page source, which taps move between.
mobile/internal/courierapi
Package courierapi stands in for the parcels service's couriers' API in the mobile packs' integration tests, where the courier apps find it: 127.0.0.1:8400 on the host.
 Package courierapi stands in for the parcels service's couriers' API in the mobile packs' integration tests, where the courier apps find it: 127.0.0.1:8400 on the host.
mobile/internal/scene
Package scene is a 3D scene as axx plays it to an app's camera, whatever file it came from: what is in front of the phone, where the phone is, and the objects a scenario names.
 Package scene is a 3D scene as axx plays it to an app's camera, whatever file it came from: what is in front of the phone, where the phone is, and the objects a scenario names.
mobile/ios
Package mobileios is the mobile-ios pack: iOS apps on simulators, which axx drives through WebDriverAgent.
 Package mobileios is the mobile-ios pack: iOS apps on simulators, which axx drives through WebDriverAgent.
mock
Package mock verifies requests received by WireMock mocks through the WireMock admin API.
 Package mock verifies requests received by WireMock mocks through the WireMock admin API.
models/android
Package modelsandroid answers platform APIs inside debuggable emulator apps through an ART TI agent attached before application binding.
 Package modelsandroid answers platform APIs inside debuggable emulator apps through an ART TI agent attached before application binding.
models/core
Package modelscore is the models-core pack: stubs of embedded models, the models an app or a service loads and runs itself.
 Package modelscore is the models-core pack: stubs of embedded models, the models an app or a service loads and runs itself.
models/core/contract
Package contract is what an app relies on from a model: its inputs and outputs, as the model's format declares them, what they mean (an image's layout, a classifier's labels, quantization), and the format's version.
 Package contract is what an app relies on from a model: its inputs and outputs, as the model's format declares them, what they mean (an image's layout, a classifier's labels, quantization), and the format's version.
models/core/format
Package format lists the model formats stubs are written in: for each, how a model's contract is read from a model, and how a stub is written as one.
 Package format lists the model formats stubs are written in: for each, how a model's contract is read from a model, and how a stub is written as one.
models/core/format/coreml
Package coreml reads Core ML models' contracts and writes stubs as Core ML models, with the protobuf wire format of Core ML's specification (coremltools' mlmodel/format: Model.proto, FeatureTypes.proto, NeuralNetwork.proto) and no generated code.
 Package coreml reads Core ML models' contracts and writes stubs as Core ML models, with the protobuf wire format of Core ML's specification (coremltools' mlmodel/format: Model.proto, FeatureTypes.proto, NeuralNetwork.proto) and no generated code.
models/core/format/ctranslate2
Package ctranslate2 reads CTranslate2 models' contracts (model.bin, in a folder of its config.json, vocabulary and tokenizer: faster-whisper's speech recognizers) and writes their stubs: a Whisper's weights of the real model's sizes (package whisper), in the variables CTranslate2's Whisper spec has (its attention's projections fused, as its converter fuses them), its scalars the real model's.
 Package ctranslate2 reads CTranslate2 models' contracts (model.bin, in a folder of its config.json, vocabulary and tokenizer: faster-whisper's speech recognizers) and writes their stubs: a Whisper's weights of the real model's sizes (package whisper), in the variables CTranslate2's Whisper spec has (its attention's projections fused, as its converter fuses them), its scalars the real model's.
models/core/format/executorch
Package executorch reads ExecuTorch programs' contracts (.pte, the models PyTorch's on-device runtime runs in Android and iOS apps) and writes stubs as ExecuTorch programs: the ONNX stub's graph (package onnx), each operator one or more of the portable kernels' calls (aten's out variants), its tensors' memory planned, its constants in the program, with flatbuffers (schema/program.fbs) and no generated code.
 Package executorch reads ExecuTorch programs' contracts (.pte, the models PyTorch's on-device runtime runs in Android and iOS apps) and writes stubs as ExecuTorch programs: the ONNX stub's graph (package onnx), each operator one or more of the portable kernels' calls (aten's out variants), its tensors' memory planned, its constants in the program, with flatbuffers (schema/program.fbs) and no generated code.
models/core/format/foundationmodels
Package foundationmodels writes stubs of Foundation Models language models: a Swift type of the LanguageModel protocol (iOS, macOS and visionOS 27), which an app's test build gives its sessions in place of SystemLanguageModel, and which answers a prompt as its mappings say.
 Package foundationmodels writes stubs of Foundation Models language models: a Swift type of the LanguageModel protocol (iOS, macOS and visionOS 27), which an app's test build gives its sessions in place of SystemLanguageModel, and which answers a prompt as its mappings say.
models/core/format/gguf
Package gguf reads and writes GGUF models, llama.cpp's format (and that of the runtimes built on it: node-llama-cpp, llama-cpp-python, llama.rn, LM Studio's and Ollama's engines): its metadata, which has the model's architecture, hyperparameters, tokenizer and chat template, and its tensors.
 Package gguf reads and writes GGUF models, llama.cpp's format (and that of the runtimes built on it: node-llama-cpp, llama-cpp-python, llama.rn, LM Studio's and Ollama's engines): its metadata, which has the model's architecture, hyperparameters, tokenizer and chat template, and its tensors.
models/core/format/internal/textenc
Package textenc reads the contracts of text encoders, the models of a text's tokens Hugging Face's exporters write, of every format that has them (ONNX, Core ML).
 Package textenc reads the contracts of text encoders, the models of a text's tokens Hugging Face's exporters write, of every format that has them (ONNX, Core ML).
models/core/format/keras
Package keras reads Keras models' contracts (.keras, Keras 3's: a zip of the model's config and its weights, model.weights.h5; and .h5, the HDF5 file Keras 2 and 3 save a model in) and writes stubs as Keras models of the layers every Keras has (AveragePooling2D, LayerNormalization, Dense, GlobalMaxPooling1D, ReLU...): the input reduced as matching reduces it, its correlation with each key, the best's one-hot, and the answers' table's product with it; a text's tokens found by an Embedding and a causal Conv1D. A model's config is Keras's JSON, its weights HDF5 (package hdf5): no Python, no code in the model.
 Package keras reads Keras models' contracts (.keras, Keras 3's: a zip of the model's config and its weights, model.weights.h5; and .h5, the HDF5 file Keras 2 and 3 save a model in) and writes stubs as Keras models of the layers every Keras has (AveragePooling2D, LayerNormalization, Dense, GlobalMaxPooling1D, ReLU...): the input reduced as matching reduces it, its correlation with each key, the best's one-hot, and the answers' table's product with it; a text's tokens found by an Embedding and a causal Conv1D. A model's config is Keras's JSON, its weights HDF5 (package hdf5): no Python, no code in the model.
models/core/format/litertlm
Package litertlm reads and writes LiteRT-LM models (.litertlm), the on-device language models Android and iOS apps run with LiteRT-LM (and MediaPipe's LLM inference): a header of their system metadata and their sections (a TFLite model of prefill and decode signatures, the tokenizer, the LLM metadata), then the sections.
 Package litertlm reads and writes LiteRT-LM models (.litertlm), the on-device language models Android and iOS apps run with LiteRT-LM (and MediaPipe's LLM inference): a header of their system metadata and their sections (a TFLite model of prefill and decode signatures, the tokenizer, the LLM metadata), then the sections.
models/core/format/mlc
Package mlc reads the contracts of MLC LLM's language models (WebLLM's, in pages, and MLC LLM's apps'): a folder of mlc-chat-config.json (the model's architecture, quantization and chat template), tensor-cache.json (its weights' records, in the shards beside it) and its tokenizer, which a model library compiled for that architecture and quantization runs.
 Package mlc reads the contracts of MLC LLM's language models (WebLLM's, in pages, and MLC LLM's apps'): a folder of mlc-chat-config.json (the model's architecture, quantization and chat template), tensor-cache.json (its weights' records, in the shards beside it) and its tokenizer, which a model library compiled for that architecture and quantization runs.
models/core/format/mnn
Package mnn reads MNN models' contracts (.mnn, the models Android, iOS and server apps run with Alibaba's MNN) and writes stubs as MNN models: the ONNX stub's graph (package onnx) translated into MNN's ops, as its converter translates an ONNX model's (its integers int32s, its layout NCHW, its pooling of its packed layout), with flatbuffers and no generated code.
 Package mnn reads MNN models' contracts (.mnn, the models Android, iOS and server apps run with Alibaba's MNN) and writes stubs as MNN models: the ONNX stub's graph (package onnx) translated into MNN's ops, as its converter translates an ONNX model's (its integers int32s, its layout NCHW, its pooling of its packed layout), with flatbuffers and no generated code.
models/core/format/ncnn
Package ncnn reads ncnn models' contracts (.param, its weights beside it in .bin: the models Android and iOS apps run with Tencent's ncnn) and writes stubs as ncnn models of the layers every ncnn build registers (Pooling, Reduction, BinaryOp, UnaryOp, InnerProduct, Clip...): the input reduced as matching reduces it, its correlation with each key (InnerProduct), the best's one-hot (its score the greatest, as Reduction and Clip give it, the first of equal ones), and the answers' table's product with it, of no batch, as ncnn's blobs are.
 Package ncnn reads ncnn models' contracts (.param, its weights beside it in .bin: the models Android and iOS apps run with Tencent's ncnn) and writes stubs as ncnn models of the layers every ncnn build registers (Pooling, Reduction, BinaryOp, UnaryOp, InnerProduct, Clip...): the input reduced as matching reduces it, its correlation with each key (InnerProduct), the best's one-hot (its score the greatest, as Reduction and Clip give it, the first of equal ones), and the answers' table's product with it, of no batch, as ncnn's blobs are.
models/core/format/onnx
Package onnx reads ONNX models' contracts and writes stubs as ONNX models, with the protobuf wire format of onnx.proto (https://github.com/onnx/onnx/blob/main/onnx/onnx.proto) and no generated code: a model and its graph are a handful of fields.
 Package onnx reads ONNX models' contracts and writes stubs as ONNX models, with the protobuf wire format of onnx.proto (https://github.com/onnx/onnx/blob/main/onnx/onnx.proto) and no generated code: a model and its graph are a handful of fields.
models/core/format/openaiwhisper
Package openaiwhisper reads OpenAI Whisper's checkpoints' contracts (the openai-whisper package's models: tiny.en.pt..., torch.save's dicts of their dimensions and weights) and writes their stubs: a Whisper's weights of the real model's sizes (package whisper), by OpenAI's names, its matrices of half precision as the real checkpoint's are, which whisper.load_model loads from the stub's path.
 Package openaiwhisper reads OpenAI Whisper's checkpoints' contracts (the openai-whisper package's models: tiny.en.pt..., torch.save's dicts of their dimensions and weights) and writes their stubs: a Whisper's weights of the real model's sizes (package whisper), by OpenAI's names, its matrices of half precision as the real checkpoint's are, which whisper.load_model loads from the stub's path.
models/core/format/openvino
Package openvino reads OpenVINO models' contracts and writes stubs as OpenVINO models (IR: a graph's XML, its weights' .bin beside it), the models Intel's runtime runs in desktop apps, their plugins, and services.
 Package openvino reads OpenVINO models' contracts and writes stubs as OpenVINO models (IR: a graph's XML, its weights' .bin beside it), the models Intel's runtime runs in desktop apps, their plugins, and services.
models/core/format/parakeet
Package parakeet reads Parakeet CTC model contracts and writes stubs as Parakeet GGUF models, which parakeet.cpp runs as it runs NVIDIA's: a frontend of its own (the app gives parakeet.cpp a sound), a subsampling that carries each mel band to the encoder, an encoder layer whose attention averages the sound's normalized frames, and a CTC head that compares the average's direction with each mapping's key and spells the nearest mapping's transcript (one vocabulary token an answer).
 Package parakeet reads Parakeet CTC model contracts and writes stubs as Parakeet GGUF models, which parakeet.cpp runs as it runs NVIDIA's: a frontend of its own (the app gives parakeet.cpp a sound), a subsampling that carries each mel band to the encoder, an encoder layer whose attention averages the sound's normalized frames, and a CTC head that compares the average's direction with each mapping's key and spells the nearest mapping's transcript (one vocabulary token an answer).
models/core/format/piper
Package piper reads Piper voice contracts and writes their stubs: an ONNX model and a voice .json beside it.
 Package piper reads Piper voice contracts and writes their stubs: an ONNX model and a voice .json beside it.
models/core/format/platform
Package platform writes prebuilt fixtures for platform model APIs.
 Package platform writes prebuilt fixtures for platform model APIs.
models/core/format/platform/platformtest
Package platformtest builds platform API stubs for the surface packs' tests.
 Package platformtest builds platform API stubs for the surface packs' tests.
models/core/format/safetensors
Package safetensors reads the contracts of language models as Hugging Face's repositories have them (a folder of config.json, model.safetensors and the tokenizer's files: the models Python services load with transformers' AutoModelForCausalLM and pipeline) and writes stubs as such models: a GGUF stub's transformer of llama's architecture (package gguf), its weights in a safetensors file, and the config.json of a LlamaForCausalLM of them, beside the real model's tokenizer and generation config.
 Package safetensors reads the contracts of language models as Hugging Face's repositories have them (a folder of config.json, model.safetensors and the tokenizer's files: the models Python services load with transformers' AutoModelForCausalLM and pipeline) and writes stubs as such models: a GGUF stub's transformer of llama's architecture (package gguf), its weights in a safetensors file, and the config.json of a LlamaForCausalLM of them, beside the real model's tokenizer and generation config.
models/core/format/tensorflow
Package tensorflow reads TensorFlow SavedModels' contracts (saved_model.pb: the models TF Serving and Python services load) and writes stubs as SavedModels: the ONNX stub's graph (package onnx) translated into TensorFlow's operations, a graph of constants with no variables, whose signature is the real model's, its inputs and outputs the real model's tensors' names too.
 Package tensorflow reads TensorFlow SavedModels' contracts (saved_model.pb: the models TF Serving and Python services load) and writes stubs as SavedModels: the ONNX stub's graph (package onnx) translated into TensorFlow's operations, a graph of constants with no variables, whose signature is the real model's, its inputs and outputs the real model's tensors' names too.
models/core/format/tesseract
Package tesseract writes stubs as Tesseract's traineddata: an LSTM recognizer, its unicharset and recoder, and the language config Tesseract reads when it loads them.
 Package tesseract writes stubs as Tesseract's traineddata: an LSTM recognizer, its unicharset and recoder, and the language config Tesseract reads when it loads them.
models/core/format/tfjs
Package tfjs reads TensorFlow.js graph models' contracts (model.json and its weights' shards, as TensorFlow.js's converter writes them: the models pages, Node.js services and React Native apps load with tf.loadGraphModel) and writes stubs as graph models: the SavedModel stub's graph (package tensorflow), its integers TensorFlow.js's int32, its constants in one shard, its signature the real model's.
 Package tfjs reads TensorFlow.js graph models' contracts (model.json and its weights' shards, as TensorFlow.js's converter writes them: the models pages, Node.js services and React Native apps load with tf.loadGraphModel) and writes stubs as graph models: the SavedModel stub's graph (package tensorflow), its integers TensorFlow.js's int32, its constants in one shard, its signature the real model's.
models/core/format/tflite
Package tflite reads TFLite (LiteRT) models' contracts and writes stubs as TFLite models, with the flatbuffers of LiteRT's schema (tensorflow/compiler/mlir/lite/schema/schema.fbs) and of its metadata (tflite-support's metadata_schema.fbs), and no generated code: a field is read and written by its slot, its place in its table's declaration (a union takes two, its type's and its value's).
 Package tflite reads TFLite (LiteRT) models' contracts and writes stubs as TFLite models, with the flatbuffers of LiteRT's schema (tensorflow/compiler/mlir/lite/schema/schema.fbs) and of its metadata (tflite-support's metadata_schema.fbs), and no generated code: a field is read and written by its slot, its place in its table's declaration (a union takes two, its type's and its value's).
models/core/format/torchscript
Package torchscript reads TorchScript modules' contracts (.pt, as torch.jit.save writes them: the models Python services load with torch.jit.load, C++ services with LibTorch, Triton with its PyTorch backend) and writes stubs as TorchScript modules: the ONNX stub's graph (package onnx) as a frozen module's code, which TorchScript compiles when it loads it, its tables the module's constants.
 Package torchscript reads TorchScript modules' contracts (.pt, as torch.jit.save writes them: the models Python services load with torch.jit.load, C++ services with LibTorch, Triton with its PyTorch backend) and writes stubs as TorchScript modules: the ONNX stub's graph (package onnx) as a frozen module's code, which TorchScript compiles when it loads it, its tables the module's constants.
models/core/format/whispercpp
Package whispercpp reads whisper.cpp's models' contracts (a ggml model file: ggml-tiny.bin...) and writes their stubs: a Whisper's weights of the real model's sizes (package whisper), as whisper.cpp's model file has them, its matrices of half precision (whisper.cpp's convolutions take no other), its mel filters and vocabulary the real model's.
 Package whispercpp reads whisper.cpp's models' contracts (a ggml model file: ggml-tiny.bin...) and writes their stubs: a Whisper's weights of the real model's sizes (package whisper), as whisper.cpp's model file has them, its matrices of half precision (whisper.cpp's convolutions take no other), its mel filters and vocabulary the real model's.
models/core/internal/coremlrun
Package coremlrun runs Core ML models with Core ML, on a Mac, for the tests that hold stubs to what they answer: each model compiled as Xcode compiles it (coremlcompiler), and run by a program built with Xcode's Swift.
 Package coremlrun runs Core ML models with Core ML, on a Mac, for the tests that hold stubs to what they answer: each model compiled as Xcode compiles it (coremlcompiler), and run by a program built with Xcode's Swift.
models/core/internal/ct2run
Package ct2run runs speech recognizers with faster-whisper (CTranslate2's Whisper), for the tests that hold stubs to what they answer: its Python package, pinned by its hashes, which Python services transcribe with.
 Package ct2run runs speech recognizers with faster-whisper (CTranslate2's Whisper), for the tests that hold stubs to what they answer: its Python package, pinned by its hashes, which Python services transcribe with.
models/core/internal/detmath
Package detmath has the math functions a stub's build uses, the same bit for bit on every machine.
 Package detmath has the math functions a stub's build uses, the same bit for bit on every machine.
models/core/internal/executorchrun
Package executorchrun runs ExecuTorch programs (.pte) with ExecuTorch's runtime, for the tests that hold stubs to what they answer: its Python package (and PyTorch's CPU build), pinned by their hashes.
 Package executorchrun runs ExecuTorch programs (.pte) with ExecuTorch's runtime, for the tests that hold stubs to what they answer: its Python package (and PyTorch's CPU build), pinned by their hashes.
models/core/internal/fmrun
Package fmrun runs Foundation Models stubs with Foundation Models, on a Mac of macOS 27 with Xcode 27, for the tests that hold them to what they answer: a stub (its Swift type named Stub) is built with a runner by Xcode's Swift, and the runner gives it to sessions, as an app does.
 Package fmrun runs Foundation Models stubs with Foundation Models, on a Mac of macOS 27 with Xcode 27, for the tests that hold them to what they answer: a stub (its Swift type named Stub) is built with a runner by Xcode's Swift, and the runner gives it to sessions, as an app does.
models/core/internal/genai
Package genai runs language models with ONNX Runtime GenAI, the library apps run ONNX language models with (on Windows, Android and iOS, and in services), for the tests that hold stubs to what they answer: its Python package, pinned by its hashes.
 Package genai runs language models with ONNX Runtime GenAI, the library apps run ONNX language models with (on Windows, Android and iOS, and in services), for the tests that hold stubs to what they answer: its Python package, pinned by its hashes.
models/core/internal/hdf5
Package hdf5 writes and reads the HDF5 files models keep their weights and configs in (Keras's model.weights.h5 and .h5 models): groups, attributes, and datasets of numbers and strings, as h5py writes and reads them.
 Package hdf5 writes and reads the HDF5 files models keep their weights and configs in (Keras's model.weights.h5 and .h5 models): groups, attributes, and datasets of numbers and strings, as h5py writes and reads them.
models/core/internal/litert
Package litert runs TFLite models with LiteRT, Google's runtime of TFLite models, for the tests that hold stubs to what they answer: LiteRT.js (its WebAssembly build, the CPU's kernels), pinned by its lockfile, run by the Node.js axx pins.
 Package litert runs TFLite models with LiteRT, Google's runtime of TFLite models, for the tests that hold stubs to what they answer: LiteRT.js (its WebAssembly build, the CPU's kernels), pinned by its lockfile, run by the Node.js axx pins.
models/core/internal/litertlmrun
Package litertlmrun runs LiteRT-LM models with LiteRT-LM, the engine of the on-device language models Android and iOS apps run (its Python package, the same C++ engine), for the tests that hold stubs to what they answer.
 Package litertlmrun runs LiteRT-LM models with LiteRT-LM, the engine of the on-device language models Android and iOS apps run (its Python package, the same C++ engine), for the tests that hold stubs to what they answer.
models/core/internal/litertpy
Package litertpy runs TFLite models with LiteRT's interpreter: its Python package, the C++ interpreter apps run, which has every tensor type (int8, which LiteRT.js has not), for the tests that hold stubs to what they answer.
 Package litertpy runs TFLite models with LiteRT's interpreter: its Python package, the C++ interpreter apps run, which has every tensor type (int8, which LiteRT.js has not), for the tests that hold stubs to what they answer.
models/core/internal/llamacpp
Package llamacpp runs GGUF models with llama.cpp, the runtime most apps and services load GGUF models with (directly, or through node-llama-cpp, llama-cpp-python, llama.rn...), for the tests that hold stubs to what they answer: node-llama-cpp's prebuilt llama.cpp, pinned by its lockfile, run by the Node.js axx pins.
 Package llamacpp runs GGUF models with llama.cpp, the runtime most apps and services load GGUF models with (directly, or through node-llama-cpp, llama-cpp-python, llama.rn...), for the tests that hold stubs to what they answer: node-llama-cpp's prebuilt llama.cpp, pinned by its lockfile, run by the Node.js axx pins.
models/core/internal/lm
Package lm is what the formats of language models' stubs share: their models' tokenizers (as llama.cpp and SentencePiece tokenize), and a stub's plan: its mappings' texts as the tokens a prompt has where it has them, its answers' tokens, and the contexts that tell each next token.
 Package lm is what the formats of language models' stubs share: their models' tokenizers (as llama.cpp and SentencePiece tokenize), and a stub's plan: its mappings' texts as the tokens a prompt has where it has them, its answers' tokens, and the contexts that tell each next token.
models/core/internal/mediapipe
Package mediapipe runs models with MediaPipe Tasks, Google's on-device tasks (object detection, image classification...) that Android, iOS and web apps run models with, for the tests that hold stubs to what the tasks make of them: MediaPipe's Python package, pinned with its dependencies by their hashes, which runs the same C++ tasks, in a virtual environment uv makes (uv is one of the repository's tools).
 Package mediapipe runs models with MediaPipe Tasks, Google's on-device tasks (object detection, image classification...) that Android, iOS and web apps run models with, for the tests that hold stubs to what the tasks make of them: MediaPipe's Python package, pinned with its dependencies by their hashes, which runs the same C++ tasks, in a virtual environment uv makes (uv is one of the repository's tools).
models/core/internal/mnnrun
Package mnnrun runs MNN models with MNN, the runtime Android, iOS and server apps link, for the tests that hold stubs to what they answer: its Python package, pinned by its hashes.
 Package mnnrun runs MNN models with MNN, the runtime Android, iOS and server apps link, for the tests that hold stubs to what they answer: its Python package, pinned by its hashes.
models/core/internal/ncnnrun
Package ncnnrun runs ncnn models with ncnn, the runtime Android and iOS apps link, for the tests that hold stubs to what they answer: its Python package, pinned by its hashes.
 Package ncnnrun runs ncnn models with ncnn, the runtime Android and iOS apps link, for the tests that hold stubs to what they answer: its Python package, pinned by its hashes.
models/core/internal/openaiwhisperrun
Package openaiwhisperrun runs speech recognizers with OpenAI's whisper package (openai-whisper, of PyTorch's CPU build), for the tests that hold stubs to what they answer: pinned by its hashes, which Python services transcribe with.
 Package openaiwhisperrun runs speech recognizers with OpenAI's whisper package (openai-whisper, of PyTorch's CPU build), for the tests that hold stubs to what they answer: pinned by its hashes, which Python services transcribe with.
models/core/internal/openvinorun
Package openvinorun runs OpenVINO models (their IR) with OpenVINO's runtime, on the CPU, for the tests that hold stubs to what they answer: its Python package, pinned by its hashes, the C++ runtime apps link.
 Package openvinorun runs OpenVINO models (their IR) with OpenVINO's runtime, on the CPU, for the tests that hold stubs to what they answer: its Python package, pinned by its hashes, the C++ runtime apps link.
models/core/internal/ort
Package ort runs ONNX models with ONNX Runtime, the official runtime most apps and services load ONNX models with, for the tests that hold stubs to what they answer: onnxruntime-node, pinned by its lockfile, run by the Node.js axx pins.
 Package ort runs ONNX models with ONNX Runtime, the official runtime most apps and services load ONNX models with, for the tests that hold stubs to what they answer: onnxruntime-node, pinned by its lockfile, run by the Node.js axx pins.
models/core/internal/parakeetrun
Package parakeetrun runs the approved Parakeet release in a small Linux container, for CTC model conformance tests.
 Package parakeetrun runs the approved Parakeet release in a small Linux container, for CTC model conformance tests.
models/core/internal/pb
Package pb writes and reads protobuf messages by their fields' numbers, with the wire format and no generated code, for the formats that are protobufs (ONNX, Core ML): a model is a handful of fields.
 Package pb writes and reads protobuf messages by their fields' numbers, with the wire format and no generated code, for the formats that are protobufs (ONNX, Core ML): a model is a handful of fields.
models/core/internal/pickle
Package pickle writes and reads Python's pickles of the values PyTorch's files have (torch.save's and torch.jit.save's data.pkl): dicts, tuples, strings, numbers and tensors, a tensor its storage's persistent id.
 Package pickle writes and reads Python's pickles of the values PyTorch's files have (torch.save's and torch.jit.save's data.pkl): dicts, tuples, strings, numbers and tensors, a tensor its storage's persistent id.
models/core/internal/piperrun
Package piperrun runs Piper voices in the real Python runtime, in a hash-pinned Linux container, for the format's integration tests.
 Package piperrun runs Piper voices in the real Python runtime, in a hash-pinned Linux container, for the format's integration tests.
models/core/internal/tfjsrun
Package tfjsrun runs TensorFlow.js graph models with TensorFlow.js, the library pages, Node.js services and React Native apps load them with, for the tests that hold stubs to what they answer: its core, converter and CPU backend, pinned by their lockfile, run by the Node.js axx pins.
 Package tfjsrun runs TensorFlow.js graph models with TensorFlow.js, the library pages, Node.js services and React Native apps load them with, for the tests that hold stubs to what they answer: its core, converter and CPU backend, pinned by their lockfile, run by the Node.js axx pins.
models/core/internal/tfrun
Package tfrun runs TensorFlow SavedModels, and Keras models with Keras 3 and tf_keras (Keras 2), with TensorFlow, for the tests that hold stubs to what they answer: its Python packages, pinned by their hashes, which TF Serving's runtime and Python services load models with.
 Package tfrun runs TensorFlow SavedModels, and Keras models with Keras 3 and tf_keras (Keras 2), with TensorFlow, for the tests that hold stubs to what they answer: its Python packages, pinned by their hashes, which TF Serving's runtime and Python services load models with.
models/core/internal/torchrun
Package torchrun runs TorchScript modules with PyTorch, whose loader (torch.jit.load) Python services, LibTorch's C++ services and Triton's PyTorch backend share, for the tests that hold stubs to what they answer: its Python package's CPU build, pinned by its hashes.
 Package torchrun runs TorchScript modules with PyTorch, whose loader (torch.jit.load) Python services, LibTorch's C++ services and Triton's PyTorch backend share, for the tests that hold stubs to what they answer: its Python package's CPU build, pinned by its hashes.
models/core/internal/transformersjs
Package transformersjs runs language models with transformers.js, Hugging Face's runtime of ONNX models in JavaScript (in pages, Electron apps and Node.js services, on ONNX Runtime), for the tests that hold stubs to what they answer: its text-generation pipeline, as apps run it, pinned by its lockfile, run by the Node.js axx pins.
 Package transformersjs runs language models with transformers.js, Hugging Face's runtime of ONNX models in JavaScript (in pages, Electron apps and Node.js services, on ONNX Runtime), for the tests that hold stubs to what they answer: its text-generation pipeline, as apps run it, pinned by its lockfile, run by the Node.js axx pins.
models/core/internal/transformersrun
Package transformersrun runs language models with Hugging Face's transformers, the library Python services load them with, for the tests that hold stubs to what they answer: its Python package and PyTorch's CPU build, pinned by their hashes.
 Package transformersrun runs language models with Hugging Face's transformers, the library Python services load them with, for the tests that hold stubs to what they answer: its Python package and PyTorch's CPU build, pinned by their hashes.
models/core/internal/uvenv
Package uvenv makes the Python environments of the tests that run models with Python runtimes (LiteRT's, MediaPipe's, LiteRT-LM's): a virtual environment uv makes (uv is one of the repository's tools), of packages pinned with their dependencies by their hashes, once, in axx's cache.
 Package uvenv makes the Python environments of the tests that run models with Python runtimes (LiteRT's, MediaPipe's, LiteRT-LM's): a virtual environment uv makes (uv is one of the repository's tools), of packages pinned with their dependencies by their hashes, once, in axx's cache.
models/core/internal/webllmrun
Package webllmrun runs MLC LLM's language models with WebLLM, in a page of Chromium on the machine's GPU (WebGPU), as web apps run them, for the tests that hold stubs to what they answer: WebLLM and Playwright's Chromium, pinned by their lockfile, run by the Node.js axx pins.
 Package webllmrun runs MLC LLM's language models with WebLLM, in a page of Chromium on the machine's GPU (WebGPU), as web apps run them, for the tests that hold stubs to what they answer: WebLLM and Playwright's Chromium, pinned by their lockfile, run by the Node.js axx pins.
models/core/internal/whisper
Package whisper compiles a speech recognizer's stub into the weights of Whisper's own architecture, of the real model's sizes: an encoder of two convolutions and transformer layers of LayerNorms and GELUs, and a decoder that attends to it.
 Package whisper compiles a speech recognizer's stub into the weights of Whisper's own architecture, of the real model's sizes: an encoder of two convolutions and transformer layers of LayerNorms and GELUs, and a decoder that attends to it.
models/core/internal/whispercpprun
Package whispercpprun runs speech recognizers with whisper.cpp (its Python binding, pywhispercpp, of whisper.cpp's library as its releases build it), for the tests that hold stubs to what they answer: pinned by its hashes.
 Package whispercpprun runs speech recognizers with whisper.cpp (its Python binding, pywhispercpp, of whisper.cpp's library as its releases build it), for the tests that hold stubs to what they answer: pinned by its hashes.
models/core/mappings
Package mappings reads a stub's mappings, as WireMock reads its stubs: each JSON file of a stub's mappings folder holds a mapping, or several under "mappings".
 Package mappings reads a stub's mappings, as WireMock reads its stubs: each JSON file of a stub's mappings folder holds a mapping, or several under "mappings".
models/core/match
Package match is how a stub matches an input to a mapping's: the input is reduced to what is compared, and the nearest key answers, when it is alike enough.
 Package match is how a stub matches an input to a mapping's: the input is reduced to what is compared, and the nearest key answers, when it is alike enough.
models/core/modelstest
Package modelstest is what a model format's tests hold its stubs to, the formats of the models-core pack and a pack's alike: stubs' directories (a contract, mappings, and the pictures they name, drawn), and Conform, the cases every format's stubs answer in the format's runtime as the stub's reference does.
 Package modelstest is what a model format's tests hold its stubs to, the formats of the models-core pack and a pack's alike: stubs' directories (a contract, mappings, and the pictures they name, drawn), and Conform, the cases every format's stubs answer in the format's runtime as the stub's reference does.
models/core/stub
Package stub resolves a stub: its model's contract, and its mappings' keys and answers, as the format writers build them into a model, and as the stub answers an input (Answer, the reference the writers are held to).
 Package stub resolves a stub: its model's contract, and its mappings' keys and answers, as the format writers build them into a model, and as the stub answers an input (Answer, the reference the writers are held to).
models/core/task
Package task turns a mapping's answer, written in its model's task's terms (a classifier's label and score), into the values of the model's outputs.
 Package task turns a mapping's answer, written in its model's task's terms (a classifier's label and score), into the values of the model's outputs.
models/core/tokenize
Package tokenize tokenizes a text as the apps of encoder models (text classifiers, text embedders) do before the model has it: as MediaPipe's text tasks tokenize (BERT's WordPiece, and a regular expression's words), so that a stub matches a mapping's text in the tokens' ids the app gives its model.
 Package tokenize tokenizes a text as the apps of encoder models (text classifiers, text embedders) do before the model has it: as MediaPipe's text tasks tokenize (BERT's WordPiece, and a regular expression's words), so that a stub matches a mapping's text in the tokens' ids the app gives its model.
models/internal/apple
Package apple builds the library axx loads into an app on an Apple platform (the iOS Simulator's, a Mac's), which answers the app's calls to Apple's models (Vision, Speech, Foundation Models) and its microphone from the stubs in its axx-models folder, and lists those APIs.
 Package apple builds the library axx loads into an app on an Apple platform (the iOS Simulator's, a Mac's), which answers the app's calls to Apple's models (Vision, Speech, Foundation Models) and its microphone from the stubs in its axx-models folder, and lists those APIs.
models/ios
Package modelsios answers platform model requests in debug simulator apps from prebuilt files in the app's axx-models folder.
 Package modelsios answers platform model requests in debug simulator apps from prebuilt files in the app's axx-models folder.
models/linux
Package modelslinux answers Linux apps' system models from the stubs in the app's axx-models folder, in the desktops desktop-linux runs: Tesseract's language data, through its documented TESSDATA_PREFIX, and speech-dispatcher's voice, through its user configuration, which speaks with the Piper voice stub.
 Package modelslinux answers Linux apps' system models from the stubs in the app's axx-models folder, in the desktops desktop-linux runs: Tesseract's language data, through its documented TESSDATA_PREFIX, and speech-dispatcher's voice, through its user configuration, which speaks with the Piper voice stub.
models/macos
Package modelsmacos answers Mac apps' calls to Apple's models (Vision, Speech, Foundation Models) and their microphone from prebuilt files in the app's axx-models folder, through the library desktop-macos loads into the app as it starts.
 Package modelsmacos answers Mac apps' calls to Apple's models (Vision, Speech, Foundation Models) and their microphone from prebuilt files in the app's axx-models folder, through the library desktop-macos loads into the app as it starts.
models/web
Package modelsweb supplies prebuilt answers to the browser's model APIs, before application scripts run.
 Package modelsweb supplies prebuilt answers to the browser's model APIs, before application scripts run.
models/windows
Package modelswindows answers the voice Windows apps speak with, SAPI's (System.Speech's and native SAPI's), from the Piper voice stub in the app's axx-models folder, in the desktops desktop-windows runs: axx's voice engine, registered as a SAPI voice and made the user's default for the scenario, speaks with Piper into the folder the speaker step hears.
 Package modelswindows answers the voice Windows apps speak with, SAPI's (System.Speech's and native SAPI's), from the Piper voice stub in the app's axx-models folder, in the desktops desktop-windows runs: axx's voice engine, registered as a SAPI voice and made the user's default for the scenario, speaks with Piper into the folder the speaker step hears.
mongo
Package mongo provides MongoDB steps: service registration and seeding.
 Package mongo provides MongoDB steps: service registration and seeding.
mqtt
Package mqtt is the mqtt pack: messages published to MQTT topics, and the messages the services under test publish there, over MQTT 5.
 Package mqtt is the mqtt pack: messages published to MQTT topics, and the messages the services under test publish there, over MQTT 5.
nats
Package nats is the nats pack: messages published to NATS subjects, and the messages the services under test publish on subjects and into JetStream streams.
 Package nats is the nats pack: messages published to NATS subjects, and the messages the services under test publish on subjects and into JetStream streams.
redis
Package redis is the redis pack: keys seeded into Redis (or Valkey, Dragonfly, KeyDB, Garnet: any server that speaks its protocol), and the keys the services under test write there.
 Package redis is the redis pack: keys seeded into Redis (or Valkey, Dragonfly, KeyDB, Garnet: any server that speaks its protocol), and the keys the services under test write there.
rest
Package rest provides the REST steps: service registration, requests (method and path, headers, payloads from OpenAPI examples or an empty template, payload properties, form encoding), execution with OpenAPI validation of the request and the response, and response assertions.
 Package rest provides the REST steps: service registration, requests (method and path, headers, payloads from OpenAPI examples or an empty template, payload properties, form encoding), execution with OpenAPI validation of the request and the response, and response assertions.
sql
Package sql provides database steps: services, seeds, selections (with polling and JSONB containment), JSON column assertions, row locks and before-insert trigger fault injection (PostgreSQL).
 Package sql provides database steps: services, seeds, selections (with polling and JSONB containment), JSON column assertions, row locks and before-insert trigger fault injection (PostgreSQL).
sse
Package sse is the sse pack: server-sent event streams a scenario opens, and the events they send.
 Package sse is the sse pack: server-sent event streams a scenario opens, and the events they send.
web/a11y
Package a11y is the web-a11y pack: pages people can use whatever their abilities.
 Package a11y is the web-a11y pack: pages people can use whatever their abilities.
web/core
Package web is the web-core pack: web apps used through real browsers, the way the people who use them do.
 Package web is the web-core pack: web apps used through real browsers, the way the people who use them do.
web/coverage
Package coverage is the web-coverage pack: how much of the web apps' JavaScript the scenarios ran.
 Package coverage is the web-coverage pack: how much of the web apps' JavaScript the scenarios ran.
web/coverage/internal/v8cov
Package v8cov turns the JavaScript coverage V8 counts into Istanbul's coverage and reports, as Node's tools do, byte for byte: it merges the coverage of a script taken several times as @bcoe/v8-coverage 1.0.2 does, converts a script, through its source map if it has one, as v8-to-istanbul 9.3.0 does, and merges, sums up and writes files as istanbul-lib-coverage 3.2.2 and istanbul-reports 3.2.0 do (lcovonly, json and json-summary).
 Package v8cov turns the JavaScript coverage V8 counts into Istanbul's coverage and reports, as Node's tools do, byte for byte: it merges the coverage of a script taken several times as @bcoe/v8-coverage 1.0.2 does, converts a script, through its source map if it has one, as v8-to-istanbul 9.3.0 does, and merges, sums up and writes files as istanbul-lib-coverage 3.2.2 and istanbul-reports 3.2.0 do (lcovonly, json and json-summary).
web/internal/driver
Package driver prepares the Playwright driver the web-core pack runs: a Node.js binary and the playwright-core package, laid out the way playwright-go expects (<dir>/node and <dir>/package/cli.js), patched so that Playwright's Inspector and recorder speak the web-core pack's steps (patch.go).
 Package driver prepares the Playwright driver the web-core pack runs: a Node.js binary and the playwright-core package, laid out the way playwright-go expects (<dir>/node and <dir>/package/cli.js), patched so that Playwright's Inspector and recorder speak the web-core pack's steps (patch.go).
web/lighthouse
Package lighthouse is the web-lighthouse pack: a web app's pages audited with Lighthouse, Google's tool for the quality of web pages, in the browser the scenario already uses: their performance, accessibility, best practices and SEO scores, and how fast they load by the Core Web Vitals.
 Package lighthouse is the web-lighthouse pack: a web app's pages audited with Lighthouse, Google's tool for the quality of web pages, in the browser the scenario already uses: their performance, accessibility, best practices and SEO scores, and how fast they load by the Core Web Vitals.
web/network
Package network is the web-network pack: what a web app's pages fetch, seen and changed from the browser.
 Package network is the web-network pack: what a web app's pages fetch, seen and changed from the browser.
web/screenshots
Package screenshots is the web-screenshots pack: pages that look as designed, compared with screenshots taken before, pixel by pixel.
 Package screenshots is the web-screenshots pack: pages that look as designed, compared with screenshots taken before, pixel by pixel.
websocket
Package websocket is the websocket pack: WebSocket connections a scenario opens, the messages it sends on them, and what it receives.
 Package websocket is the websocket pack: WebSocket connections a scenario opens, the messages it sends on them, and what it receives.
plugins
axx
Package axx is axx's plugin for Claude Code.
 Package axx is axx's plugin for Claude Code.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.