Functional Weave
Code in Rust

Publishing a capability

You have an account. This is the rest: what you are publishing, how to lay it out, how to claim a name for it, and the two commands that put it on the registry.

1

What a capability is

A capability is one function. Not a library, not a class, not a service: one function with a name, a signature, and an answer you can write down. finance.tax.add-vat adds VAT to an amount. collections.paginate cuts a list into pages.

It is implemented three times — once in TypeScript, once in Python, once in Rust — and pinned by one set of test vectors that all three must pass. Someone using it names it in one line of their code; fune build turns that into readable source in their own language, in the project’s .fune/build folder, with a header saying where it came from, so they can open it, step through it and diff it — and fune check refuses a copy that has been edited.

That is what publishing puts your name to: the three implementations agree, and the vectors say what agreeing means. Everything below exists to keep that claim true.

2

The directory layout

One directory per version. Publish the version directory, not the capability directory — the id and the version both come out of function.fune, and a directory named after them keeps a whole registry readable.

registry/finance.tax.add-vat/1.0.0/
  function.fune          metadata, signature, contract
  README.md                notes for the people deciding whether to use it
  vectors.json             the shared test cases
  impl/typescript.ts
  impl/python.py
  impl/rust.rs
  data/vat-rules.json      optional: rules that change by date or jurisdiction

The id is dotted lowercase with at least two segments. The first segment is the namespace, and it decides who may publish the name at all — see namespaces below.

Every file in the directory is uploaded, recursively, so keep build output, __pycache__ and editor leftovers out of it. A version may ship at most 64 files, and no single file may exceed 2MB.

3

function.fune

The contract. It is what the website renders, what the resolver reads, and what the integrity hash covers. It uses the same grammar as fune.project: one directive per line, # for comments, indented lines belong to the block above.

# collections.paginate
id       collections.paginate
version  1.0.0
level    1
summary  Cut a list into pages, returning the slice and the page count.
tags     collections pagination api
license  Apache-2.0
throws   yes

fn paginate<T>(items: T[], page: int, perPage: int) -> Page<T>
  items  the whole list
  page   1-based

type Page<T>  One page, and what a client needs to draw a pager.
  items       T[]
  page        int
  totalPages  int

The fn line is the signature every implementation must have, in one vocabulary with a fixed meaning in each language:

function paginate<T>(items: readonly T[], page: number, perPage: number): Page<T>
def paginate(items: Sequence[T], page: int, per_page: int) -> Page[T]
pub fn paginate<T>(items: &[T], page: i64, per_page: i64) -> Page<T>

Anything that follows the conventions is left out. The implementations are impl/typescript.ts, impl/python.py and impl/rust.rs, for whichever of them exist; the Python and Rust names are the snake_case of the ones in the manifest; a capability is pure, deterministic, off the network and does not throw unless it says otherwise.

LineWhat it has to be
idDotted lowercase, two segments or more. It never changes once published.
versionSemver. A new upload is always a new version.
level0 primitive, 1 generic concept, 2 domain function, 3 business operation, 4 workflow. Pick the lowest level that is honest.
summaryOne line under 120 characters. It is the only thing most people read.
licenseRequired. What others may use the code under once it is built into their product, as an SPDX expression: Apache-2.0, MIT OR Apache-2.0. An upload without one (or with NOASSERTION) is refused. A later minor or patch may never change it. The registry's own functions are Apache-2.0; fune new writes that as a starting point.
fnThe signature: the exported function as TypeScript names it, each parameter with its type, and -> the result. Indented lines under it are notes on a parameter, or on ->. A language whose entry breaks the snake_case convention says so on an entry line: entry python=add_vat_py.
typeA type the signature uses: a record with one indented field type [note] line per field, or a set of strings, type RoundingMode = half-up | down. It is generated into every language; implementations import it and never declare it themselves.
throwsAlso pure, deterministic, network: yes or no, written only when it is not the default. A function that reads the clock or the network cannot be pinned by a vector.
requireOther capabilities, by id and range, as in fune.project. Nothing from npm, PyPI or crates.io: the standard library and the registry, and that is all. Every import must name a required capability and something it exports in each version the range allows, or the upload is refused.

Types

A type is a built-in, one declared in the manifest, or one declared by a capability it requires directly. Each has one meaning per language; Rust borrows parameters and owns results.

ManifestTypeScriptPythonRust
intnumberinti64
floatnumberfloatf64
stringstringstr&str in, String out
boolbooleanboolbool
datestringstr&str in, String out
jsonunknownAny&Value in, Value out
recordReadonly<Record<string, unknown>>Mapping[str, Any]&Value in, Value out
map<int>Readonly<Record<string, number>>Mapping[str, int] in, Dict[str, int] out&[(String, i64)] in, Vec<(String, i64)> out
MoneyMoneyMoney&Money in, Money out
Money[]readonly Money[]Sequence[Money] in, List[Money] out&[Money] in, Vec<Money> out
string?string | nullOptional[str]Option<&str> in, Option<String> out
TTT&T in, T out

Explanations belong in README.md next to it, which is shown on the capability's page. The service checks all of this on upload with the same code fune validate runs on your machine, so a capability that validates locally is a capability that will be accepted. A package still on capability.json converts with fune migrate <dir>.

4

Vectors, and why all three languages must agree

A vector is a case: arguments in, expected value out, written in plain JSON so it belongs to no language in particular.

[
  {
    "name": "the first page of three",
    "args": [[1, 2, 3, 4, 5], 1, 2],
    "expect": { "items": [1, 2], "pages": 3 }
  },
  {
    "name": "a page past the end is empty",
    "args": [[1, 2], 9, 2],
    "expect": { "items": [], "pages": 1 }
  },
  {
    "name": "page zero is an error",
    "args": [[1, 2], 0, 2],
    "expectError": "page must be 1 or more"
  }
]

The same file runs in all three implementations. fune verify --all installs your capability into a throwaway project per language and runs every case through the real toolchain — tsc, python, cargo. If TypeScript rounds a half up and Python rounds it to even, the run fails and you have found a bug that would otherwise have been someone's wrong invoice.

This is the whole point of the registry. A capability that is verified in one language is a snippet; one that answers identically in three is something you can build on in a codebase that is not all written in the same thing. So:

  • Every function is tested. The registry refuses a version with fewer than eight cases for any function, and a function that throws needs at least one expectError case. Make them count: the ordinary case, the boundary, zero, a negative, the largest values, the rounding edge, and every error it documents.
  • expectError matches on a substring of the message, in all three languages: the TypeScript error, the Python exception and the Rust panic, which the harness catches. Use the same wording in each.
  • Vectors are the specification. If you find yourself editing a vector to match the code, work out which of the two is actually wrong.

Run both gates before you publish:

fune validate finance.tax.add-vat
fune verify --all finance.tax.add-vat

Groups: several functions in one package

Publish one function per capability unless you have a reason not to. A function that is useful on its own - adding VAT, rounding money - is its own package, found and versioned on its own. Only functions that are parts of one machine and no use apart, like a chart's scale, its inverse and a nice axis domain, belong together in a group: one manifest with a fn line for each.

fn linearScale(domain: float[], range: float[], value: float, clamp: bool) -> float
  throws  yes
fn invertLinear(domain: float[], range: float[], value: float) -> float
  throws  yes
fn niceDomain(domain: float[], count: int) -> NiceDomain
  throws  yes
impl/typescript/linear_scale.ts     one file per function, per language
impl/typescript/invert_linear.ts    import { normalise } from "./charts_scale_linear_scale.ts";
impl/typescript/nice_domain.ts
impl/python/…  impl/rust/…
vectors.json                        { "fn": "linearScale", "name": …, "args": …, "expect": … }
  • Each function has its own file in each language, named by its snake_case, and says for itself whether it throws. Types, requires and data are shared by the package.
  • Each vector names the function it calls with "fn", and every function needs eight of its own, with an error case if it throws.
  • A function may import a sibling's module, <id>_<function>, for what that file exports. The check is the same as for any import, and it is also how a slim install knows what a function needs.
  • A project can install only some functions with fune add charts.scale --only invertLinear: it gets those, the siblings they import, and the types they use. The package you publish, and each language's .fune, always carries the whole group.
  • Search finds every function by name, in every language's spelling, and the group's page gives each one its own anchor, signature and source.
5

An organisation, and a namespace to publish under

Names are not first come, first served. An organisation claims a dotted prefix — finance, or acme.billing — and from then on only its members can publish underneath it. The longest matching claim wins, and no prefix can be claimed inside another organisation's, so there is always exactly one answer to who owns a name.

Skip this and the upload is refused, with the fix in the message:

No organisation owns the “acme” namespace yet. Claim it from your organisation's settings, then publish.

So, once:

  1. Create an organisation from your settings. You become its owner.
  2. Claim the namespace your ids start with, in the organisation's settings.
  3. Add anyone else who will publish, with the publisher role or better.

Roles run reader, publisher, admin, owner. Publishing needs publisher; claiming and releasing namespaces needs admin. A namespace with published capabilities under it cannot be released, because that would leave them unowned.

Browse who owns what at http://www.functionalweave.com/orgs.

6

fune login

The CLI reads the registry without an account. Publishing needs a token, and fune login gets one. Not installed yet? Install the CLI first. By default it signs you in through the browser: it prints a short code and opens a page on this site where, signed in, you check the code and approve it. The token comes back to the terminal; your password never goes near it.

fune login --registry http://www.functionalweave.com

fune login --password asks for your username and password in the terminal instead (not echoed). Either way only the token that was issued is stored, in ~/.fune/credentials.json, keyed by registry and written readable by you alone. Against https://functionalweave.com, or inside a project whose fune.project already names this registry, or with FUNE_REGISTRY set, the flag is unnecessary:

fune login
fune whoami
fune logout

fune whoami prints who the stored token belongs to and which organisations you are in, with your role in each. fune logout forgets the token on this machine; to kill it everywhere, revoke it in your settings.

On a build machine, make a token on the website instead of typing a password into CI, and hand it over directly:

fune login --registry http://www.functionalweave.com --token "$FUNE_TOKEN"

Or leave it in the environment: with FUNE_TOKEN set, fune publish uses it without storing anything.

Either way the token is checked against the registry before it is written, so a typo fails here rather than three steps later.

7

fune publish

Point it at the version directory. It reads function.fune and every other file in there, validates the lot locally, and only then uploads.

fune publish ./registry/finance.tax.add-vat/1.1.0

Look before you leap. --dry-run does everything except the upload and says exactly what would go:

$ fune publish ./registry/finance.tax.add-vat/1.1.0 --dry-run
would publish finance.tax.add-vat @1.1.0 to http://www.functionalweave.com
  integrity  sha256-rxzv5LNCoqcL77aYY1Bp/FW3NW6mwaMdn4Ykb5AiP7k=
  languages  python, rust, typescript
  vectors    22
  files
    function.fune    612 B
    README.md          1,340 B
    impl/python.py     3,043 B
    impl/rust.rs       4,134 B
    impl/typescript.ts 3,262 B
    vectors.json       3,027 B

dry run: 6 files, 15,418 B, nothing uploaded

Validation happens on your machine first and reports every problem at once, because a round trip spent discovering a misspelled export is a round trip wasted. When something is wrong, nothing is uploaded:

invalid text.slugify@1.0.2
  - missing "summary"
  - python: "slugifyy" is not exported by impl/python.py
error 2 problems to fix before publishing
  nothing was uploaded

The three refusals that come from the service, and what each one means:

You seeIt means
did not accept that tokenNo token, or a revoked one. Run fune login.
No organisation owns …The namespace is unclaimed, or claimed by someone else, or you are not a publisher in the organisation that owns it. See namespaces.
is already publishedThat exact version exists. Bump the version and publish again.

A successful publish tells you what landed:

published finance.tax.add-vat@1.1.0 31ms
  integrity  sha256-rxzv5LNCoqcL77aYY1Bp/FW3NW6mwaMdn4Ykb5AiP7k=
  languages  python, rust, typescript
  vectors    22 pinned
  published as acme
  url        http://www.functionalweave.com/functions/finance.tax.add-vat
  package    http://www.functionalweave.com/finance.tax.add-vat/1.1.0.fune sha256 5d0c…

fune publish also takes a .fune file made by fune pack in place of the directory — see packages. Either way the same checks run and the same version lands.

8

Packages: a version as one file

A directory is the right shape to write and review a capability in. To hand one over, a version is also a single file: a .fune package, named <id>-<version>.cap. It is a JSON document with the manifest, the vectors, every implementation and any data inside it, so you can open it and read the code before you trust it.

{
  "format": "fune-package/1",
  "integrity": "sha256-/DEyZA9fylYwsE80wsSfMw+D5OhxEgeolL9agTUscBg=",
  "capability": { "id": "finance.tax.add-vat", "version": "1.0.0", … },
  "files": {
    "impl/python.py": "…the source, as text…",
    "impl/rust.rs": "…",
    "impl/typescript.ts": "…",
    "vectors.json": "…"
  }
}

Text files are stored as text; anything that is not UTF-8 is stored as { "base64": … }. Keys are sorted and there are no timestamps, so packing the same directory twice gives the same bytes, and the file this registry serves is byte for byte the file fune pack makes of the directory that was published. The integrity inside is the one lockfiles already record; a file whose contents no longer match it is refused as corrupt.

Make one locally, with the same validation fune publish runs:

$ fune pack ./registry/finance.tax.add-vat/1.0.0
packed finance.tax.add-vat @1.0.0
  integrity  sha256-/DEyZA9fylYwsE80wsSfMw+D5OhxEgeolL9agTUscBg=
  languages  python, rust, typescript
  vectors    9
  files
    capability.json    1,297 B
    impl/python.py     925 B
    impl/rust.rs       1,527 B
    impl/typescript.ts 939 B
    vectors.json       2,561 B
  sha256     df406777971af1456c0f197c2e213492c34097a86245fa980b422e2575368ccc

5 files, 7,249 B -> finance.tax.add-vat-1.0.0.fune, 8,328 B

--out names the file, or a directory to put it in.

Every published version downloads as one, yanked versions included, from the Download button on its page or directly:

curl -OJ http://www.functionalweave.com/finance.tax.add-vat/1.0.0.fune
shasum -a 256 finance.tax.add-vat-1.0.0.fune

The sha256 to compare against is on the capability's page and in each version's package entry in /index.json. /v1/capabilities/<id>/<version>/download serves the same bytes for scripts.

fune build fetches one package per version and checks its integrity against the index and the lockfile before it generates any code. To install from a file instead of the registry — an air-gapped build, say:

fune add ./finance.tax.add-vat-1.0.0.fune

That pins the file's exact version in fune.project with where it came from, copying the file into vendor/fune/ first if it lives outside the project, so commit it alongside the lockfile:

require finance.tax.add-vat  1.0.0 from=vendor/fune/finance.tax.add-vat-1.0.0.fune

Its dependencies still come from the registry. fune add finance.tax.add-vat switches it back.

One language at a time, like an image tag

The full package describes the whole function and is what you publish. A project only ever runs one language, though, so every version also downloads as one package per language: the same manifest, vectors, README and data, and only that language's implementation. It is named like a Docker tag, <id>-<version>-<language>.cap, and says which language it carries in a "language" field beside format. You are reading this in Rust, so:

curl -OJ http://www.functionalweave.com/finance.tax.add-vat/1.0.0/rust.fune
fune pull finance.tax.add-vat:rust          # the same file, checked against the index
fune pull finance.tax.add-vat@1.0.0                  # no language: the full package

A reference is <id>[@<version-or-range>][:<language>]. In a project the language defaults to the language line of fune.project, and fune build downloads only that language's package of each version, falling back to the full one from a registry that predates them. Asking a Rust project for another language (fune add finance.tax.add-vat:python) is refused: a project installs one language, and fune pull is how you fetch another.

Each language's package has its own sha256 and its own integrity, listed under package.languages in /index.json. That integrity covers the manifest and exactly the files the package carries, and it is what a project of that language records in its lockfile, whether the version came from the registry, a registry directory, the full .fune or the language's own. fune pack --language rust makes the same bytes locally; publishing one is refused, because it is not the whole function.

9

What a published version is, and how to withdraw one

It is immutable. The files, the metadata and the vectors of 1.1.0 are what they were the moment you uploaded them, for as long as the registry exists. Every version carries an integrity hash over the manifest and every shipped file, and that hash goes into the lockfile of every project that installs it — so an edit in place would break a build somewhere else, and is simply not offered.

Every published version also has a public verification report, linked from its page: whether the registry's sandbox ran its vectors (with the runner image digest, the toolchains and each language's results) or the registry's operator verified it outside the sandbox, with its lint waivers and every attempt. The registry signs each release, over its integrity and that report, with a key published at /.well-known/fune-keys.json and pinned in fune; fune build refuses a package whose bytes do not match what was signed, fune evidence <id>@<version> shows and checks a report, and every signature is in the append-only log at /v1/log.

That includes rule data. When a VAT rate changes, publish a new version; never re-issue an old one, because somebody's build is pinned to the old answer and may be reprinting a three-year-old invoice.

What you can do is withdraw a version:

fune yank finance.tax.add-vat 1.1.0 --reason "rounds the wrong way on half-pence"

A yanked version stays downloadable, so a lockfile already pinned to it can still fetch its package. It leaves the index, so nothing new resolves it: no fresh install, no range match, no dependency of anything else. The website marks it, and the reason you give is shown there.

Yanking is a toggle — run the same command again to put a version back. It is not a delete: publish a fixed version, and tell people why with the reason.

Then the last step is somebody else's:

fune add finance.tax.add-vat

Which resolves your capability out of http://www.functionalweave.com/index.json, writes the integrity hash into their lockfile, and generates the source into their project.

+

Publishing a suite

A suite is a named set of functions for one kind of app: sections in build order, each listing core and optional functions with a one-line reason, and the gaps an app like it still needs. Publish one for the apps you build, and any project — or an AI agent planning an app — can start from it.

fune suite new acme.billing-app
fune suite validate acme.billing-app.suite
fune suite publish acme.billing-app.suite --registry http://www.functionalweave.com
fune suite add acme.billing-app            # in a project: require every function it lists

The file is the .suite format the registry's own suites use: suite, title, summary, optional synonyms, apps, include and caveat lines, then section <key> <title> blocks of purpose, core <id> <why>, optional <id> <why> and gap <key> <text> lines. The registry accepts it when:

  • its id starts with a namespace your organisation owns, and you are a publisher in it (the same rule as functions);
  • every function it lists has been uploaded and not rejected — published, or still being verified (a project gets that one once it passes);
  • every suite it includes exists, with no cycle, and each line fits on one line (a title of 80 characters, a summary of 240);
  • it is at most 64 KB, 60 sections and 300 functions.

A suite has no code, so it skips the sandbox and is live as soon as it is accepted, on /suites, in search and to AI tools. Publishing the same id again replaces it; fune suite unpublish <id> takes it down, unless another suite includes it. The API is POST /v1/suites with {"source": "<the file>"} and DELETE /v1/suites/<id>, with a publishing token.

+

Suites coverage

Every suite reports its core coverage: the share of what a typical app of its kind needs that verified capabilities already cover. The method is fune-coverage/1:

  • the needs are the suite's core members, with its includes resolved (each once), and every named gap; optional members are not needs;
  • each need weighs 1, unless the suite says weight <capability-id or gap key> <n> (suite format 1.1);
  • a core member is met when it has a published version here that is not yanked, which means the sandbox verified it (or, for the registry's own functions, the seed did, after fune verify --all); a gap is never met; deprecated and unreviewed members count as met and are listed;
  • coverage = met weight ÷ total weight. The baseline is a hand-written app with no suite: 0 of the same denominator.
GET /v1/suites/<id>?language=typescript     no auth (a token adds its organisation's private suites)
  "coverage": { "method": "fune-coverage/1", "numerator": 12, "denominator": 24, "ratio": 0.5, "percent": 50,
                "needs": { "core": 12, "gaps": 12, "weighted": false },
                "met": ["auth.validate-registration", …], "unmet": [{ "key": "users-table", "kind": "gap", "weight": 1, "reason": "gap" }, …],
                "deprecated": [], "unreviewed": [],
                "baseline": { "numerator": 0, "denominator": 24, "ratio": 0, "percent": 0, "what": "…" },
                "language": { "language": "typescript", "numerator": 12, "ratio": 0.5, "percent": 50, "notIn": [] },
                "computedAt": "2026-10-10T12:00:00.000Z" }
GET /v1/suites      each suite's "coverage": { method, numerator, denominator, ratio, percent, computedAt }

MCP plan_app returns the same object for the suites it picked (null when none fits), and get_suite the full one; fune suite show <id> and fune suites print it. An unknown suite is a 404 {"error": "There is no suite …"}, as before. Read /suites for each figure.

+

Private capabilities and suites

Not everything an organisation writes is for everyone. A private capability (or suite) is visible only to the members of the organisation that owns it, in any role, and to its service tokens with the read scope. To anyone else it does not exist: it is in no listing, search result, suggestion, count, index, sitemap or llms.txt, the MCP server does not know it, and asking for it by name answers 404, exactly as for a name nobody used.

Two ways to make one, and visibility belongs to the whole capability, never one version:

  • A private namespace. An admin marks a namespace private on the organisation's Namespaces page. Everything published under it from then on is private; a public upload there is refused. A namespace with anything public under it cannot be made private, because what is public stays public.
  • One capability. fune publish <dir> --private (the API: POST /v1/publish?visibility=private) under a public namespace; fune suite publish <file> --private for a suite. The first upload decides: later versions keep it, and asking for the other is refused.

A public capability may not depend on a private one, and a public suite may not list or include one, so nothing public ever breaks for want of access. A private capability may depend on public ones and on its own organisation's private ones. Private uploads are verified in the sandbox like any other; they are not held for the first-uploads review, since only the organisation can install them.

Reading them takes a token: fune login, or FUNE_TOKEN in CI. fune add, fune build, fune search and fune mcp then include them, and fune.lock marks each one "visibility": "private" with its organisation, so a build without access says what it needs. Over HTTP the index, the API, search, downloads and the MCP server at http://www.functionalweave.com/mcp take the token as Authorization: Bearer.

+

Service tokens, for CI and AI agents

A personal token acts as you, everywhere you are a member. A service token acts as one organisation, and only as far as its scopes go. Admins create and revoke them on the organisation's Service tokens page (or POST /v1/orgs/<org>/tokens with a personal token); the secret, fune_svc_…, is shown once.

ScopeAllows
readThe organisation's private capabilities and suites: index, downloads, search, API, MCP.
publishUpload versions and yank them, under every namespace the organisation owns, or only the ones the token names.
suitesPublish and unpublish the organisation's suites, under the same namespaces.

A token may expire; its page shows when it was last used; everything it does is in the organisation's activity log under its name, and a version it publishes names it as the publisher. A public upload by a service token waits for the first-uploads review while its organisation has fewer published public versions than the registry's threshold, so a new organisation cannot skip review by minting tokens; private uploads are never held.

An agent contributing back: an admin gives it a token with read and publish, limited to a namespace such as acme.agents, in its environment as FUNE_TOKEN. It writes the function, checks it, and publishes it privately; then any project in the organisation can use it.

fune new acme.agents.parse-invoice-ref
fune validate ./acme.agents.parse-invoice-ref/1.0.0
fune verify ./acme.agents.parse-invoice-ref/1.0.0
fune publish ./acme.agents.parse-invoice-ref/1.0.0 --private --wait

Inside a project, fune mcp offers the same as the publish_function and publish_suite tools once a token that may publish is configured; each needs the id, version and visibility spelled out.

+

Organisations over the API

Everything the organisation pages do, for scripts and for platforms that create an organisation per customer. The full reference (each request, answer and error) is spec/registry-api.md.

POST   http://www.functionalweave.com/v1/orgs                       {name, displayName?, namespaces?, private?}
GET    http://www.functionalweave.com/v1/orgs/<org>
POST   http://www.functionalweave.com/v1/orgs/<org>/members               {username | email | external_id, role}
DELETE http://www.functionalweave.com/v1/orgs/<org>/members/<user or invite id>
POST   http://www.functionalweave.com/v1/orgs/<org>/namespaces            {prefix, visibility?}
POST   http://www.functionalweave.com/v1/orgs/<org>/tokens                {scopes, expires_at?, namespaces?, name?}

They take a personal token that may publish, of an admin of the organisation (creating one makes you its owner), or a partner token. Never a service token: it acts as an organisation, it does not administer one. A person adds an existing account by username at once and invites anyone else by email; the invitation (14 days, one use) works only for the account it names, and creates no account.

Partner tokens

A platform that provisions organisations for its customers (weave.cloud: one per workspace) gets a partner and its tokens, fune_ptn_…, from a registry administrator. A partner with the prefix wc- creates organisations named wc-…, up to its cap, and is an owner of exactly those: members, invitations, service tokens, and namespaces under its reserved root named for the organisation (wc-acme claims wc.acme). It cannot touch any other organisation, publish, read private work or create anyone's account. It mints its organisations a service token with publish to contribute back.

People join a partner's organisation by accepting an invitation. One that carries the partner's own id for them (external_id) says on the page that accepting also links the account to the partner; after that the partner adds the account to its other organisations by that id without asking again. Links are listed, and removed, on Linked accounts.

+

Contributing back

An agent that wrote a function for a gap in an app publishes it into the organisation, privately unless asked otherwise, with the organisation's service token (publish scope):

POST http://www.functionalweave.com/v1/orgs/<org>/capabilities
{ "manifest": "<function.fune>", "files": {"impl/typescript.ts": "…"}, "vectors": [ … ] }

fune publish ./wc.acme.parse-ref/1.0.0 --org wc-acme --wait

It also takes a .fune package or the bundle fune publish sends, and ?dry_run=1 to validate only. A draft that does not validate is answered 422 with every problem as a list. Otherwise it goes to the sandbox like any upload, and the answer's statusUrl (/v1/orgs/<org>/capabilities/<id>/versions/<v>/status) says when it is done, with each language's tally and the failing vectors.

+

Rate limits

Without a token, the MCP server (/mcp), POST /v1/check, POST /v1/plan_app and the gap signal are limited per client address. With a valid token the budget is the token's, not the address's, so agents behind one NAT do not share one: a person's tokens together 600 a minute per endpoint, a service token 1200 (its organisation 3600 in all), a partner its own budget (default 6000). Each answer carries RateLimit-Limit, RateLimit-Remaining, RateLimit-Reset and RateLimit-Policy; a refusal is 429 with Retry-After.

+

Gap demand signal

Builders tell the registry which of a suite's gaps their apps keep writing themselves, as counts and nothing else:

POST http://www.functionalweave.com/v1/signals/gaps
{ "suite": "auth", "gap_key": "mfa", "count": 7, "window": "1d" }

The suite must exist; the gap is one of its keys, or a short slug for one it does not list. Counts (1 to 1000) and windows (an hour to 30 days) are bounded, any other field is refused, and nothing about the caller is stored: the registry keeps a sum per suite, gap and day. No token is needed (30 reports an hour per address); with one, 600. Registry administrators read the top gaps on /admin/signals and GET /v1/signals/gaps.

10

Hooks: customising a capability in your app

Sometimes a capability is right except for one thing: your invoices round to whole pounds, or your VAT rate comes from your own table. You do not fork it and you do not edit the built file — fune check refuses an edited copy. You write the difference as a function of your own, in your own source, and put a marker comment directly above it. fune build wires that function into the capability’s built code. Nothing on the registry changes, and nobody else’s build is affected.

A marker is one comment line, // in TypeScript and Rust, # in Python:

fune: before  <capability-id>[.<fn>]
fune: after   <capability-id>[.<fn>]
fune: replace <dependency-id>[.<fn>] in <capability-id|*>
fune: step    <capability-id>[.<fn>] after <n|label>

A group’s functions are named <id>.<fn>; a single function needs only the id. There are four kinds:

KindYour function
beforeGets the capability’s arguments and returns them, changed or not — or throws to refuse the call.
afterGets the result, and the arguments, and returns the final result.
replaceStands in for a dependency, with the same signature. Inside the one capability named after in, calls to that dependency go to your function; other capabilities that use the dependency are unaffected, unless you write in *.
stepRuns at a numbered point inside the entry function’s body. It receives the in-scope values it names as parameters, and may return replacements for them. fune show <id> --steps lists the points, by number and by label.

One in each language:

// fune: after finance.tax.add-vat
export function roundToPounds(result: VatBreakdown): VatBreakdown { … }
# fune: replace finance.tax.vat-rate in finance.tax.add-vat
def flat_rate(jurisdiction, category, on_date): …
// fune: before money.format
pub fn normalise(amount: &Money) -> &Money { … }

Every capability’s page lists the seams it offers — its functions for before and after, each dependency it requires for replace — as marker lines ready to copy.

Keeping track of it

  • The built file says it has been customised. Its header carries a CUSTOMISED: block naming each hook and the function of yours it calls, with its file and line, so nobody reading it mistakes it for the registry’s code:
    // ─── fune · finance.tax.add-vat@1.0.0 ───────────────────────────────────
    // Add VAT to a net amount using the rate in force on the date of supply.
    // CUSTOMISED: this build runs code from your project inside finance.tax.add-vat:
    //   after addVat: roundToPounds() from src/billing.ts:14
    //   replaces finance.tax.vat-rate with charityRate() from src/tax.ts:3
    //   The shared vectors test the registry's code; `fune verify --hooked` runs them through yours.
  • fune.lock records the hooks against each capability, so a change to them shows up in review like any other change to what you build.
  • fune hooks lists every hook in the project: the kind, the capability, and your function.
  • fune check validates the markers: each must sit directly above a function, name a capability the project installs, and name a seam that capability actually offers.
  • fune verify still runs the shared vectors against the unmodified function, so it proves the capability is what the registry says it is. fune verify --hooked also runs them through your hooked build and reports which answers change. That report is information, not a failure: changing answers is what a hook is for.
11

Frameworks and language subsets

A capability is written in TypeScript, Python and Rust unless its manifest says otherwise. Some are not: a React component is TypeScript and nothing else, and a UI state helper has no business in a Rust service. Two directives say so, and the registry flags both on every listing and page, as React ^19 · TypeScript only or TypeScript only.

# form.state
id         form.state
...
languages  typescript
  • languages typescript lists the languages it is written in. Left out, it is all three. fune validate holds the package to it exactly: an implementation for each language listed, and none for any other.
  • framework react ^19 says it is written for a framework, and which versions of it. A framework implies its languages (React: TypeScript), so languages is left out. The implementation may import react and react-dom and no other third-party code, may be JSX (impl/typescript.tsx), and its signature may use three more types: element (JSX.Element), node (ReactNode) and handler<T> ((value: T) => void). A field written hint? may be left out by the caller, as React props are.
# react.form.text-field
id         react.form.text-field
version    1.0.0
level      1
summary    A labelled text input with a hint, an error message, prefix and suffix.
framework  react ^19

fn TextField(props: TextFieldProps) -> element

type TextFieldProps  One question answered in a line of text.
  label      node             the question
  id?        string           the input's id; useId() when left out
  hint?      node             help under the label
  onChange?  handler<string>  called with the new value

require react.form.form-field  ^1.0.0

Components and render tests

A component is a function that returns element and takes exactly one parameter, its props, a record type the manifest declares. Its vectors are render vectors: args is the props, and expect is the exact HTML react-dom/server’s renderToStaticMarkup makes of them. A React warning during the render fails the vector, and ids are passed in so the HTML is deterministic. Every function still needs at least eight.

{ "name": "an error marks the input invalid",
  "args": [{ "id": "email", "label": "Email address", "error": "Enter an email address" }],
  "expect": "<div class=\"fune-field fune-field--error\"><label class=\"fune-label\" for=\"email\">Email address</label>…</div>" }

What a component does when someone types cannot be rendered on a server, so it is tested the way it is written: the state change is a pure function of its own (a reducer, a count, a validator) with ordinary vectors, and the component calls it. A component that holds state or runs effects, any hook but useId, is a client component: its file starts with "use client";, fune validate refuses one that does not, and fune build keeps the directive as the first statement of the built file, which Next.js needs. A component with no state renders on the server and ships no JavaScript. Its page says which it is.

What may require what

A capability may only require one written in every language it is. A React component may require auth.password-policy, which runs in all three; auth.password-policy could never require a component, and a Python-and-Rust capability cannot require a TypeScript-only one. fune validate names the dependency and what it lacks.

Building and verifying

  • A project can only use what is written in its language. fune build in a Python or Rust project that names a TypeScript-only or React capability stops, saying so and where it was named.
  • In a TypeScript project, a React capability needs React itself, which fune does not ship: without react and react-dom installed, fune build stops with the line to run, npm install react react-dom.
  • fune verify --all runs a TypeScript-only capability in TypeScript alone, and renders a React one with the React in tooling/react; a project’s own fune verify renders with the project’s.
  • A .fune has a package for each of its languages only: a React capability’s is <id>-<version>-typescript.fune, and its page offers no Python or Rust download.

Browse them with React only, or the React form elements collection: accessible form components and the pure helpers they use.

12

Integrations: sign-in, payments, email, uploads

A function is pure and pinned by vectors. Signing a user in, taking a payment, sending an email or handing out an upload URL cannot be: each talks to someone else’s server, reads a secret and looks at the clock. An integration is the unit for that code. It is a capability like any other (an id, versions, the one-line reference, fune build, the sandbox), marked Integration · does I/O on every listing and page, with three things a function does not have:

  • Adapters. One interface, its fn lines and types, and a provider behind it for each service it can use, each an adapter file. A select variable picks the provider at run time.
  • Declared environment. Every variable it reads, by name and never by value: secret for a credential (which may not have a default), config for a setting, ? after either for one that may be unset; at the top for every provider, or indented under the one provider that reads it.
  • Contract tests instead of vectors (contracts.json): each case runs the interface through one provider against recorded HTTP exchanges or a scripted socket dialogue, with fake credentials and a fixed clock. They run offline, in a project, in fune verify --all and in the registry’s sandbox, which has no network.
format     1.1
id         email.send
version    1.0.0
level      3
kind       integration
summary    Send a transactional email through Resend, any SMTP server or the log, behind one call.
languages  typescript
throws     yes

fn sendEmail(message: EmailMessage) -> SentEmail
  async  yes

provider resend  Resend's HTTP API (resend.com)
  secret  RESEND_API_KEY  an API key from resend.com/api-keys, re_...

provider smtp  Any SMTP server: implicit TLS on 465, STARTTLS on 587
  secret  SMTP_URL  smtps://user:password@host:465

provider log  Writes each message to the log instead of sending it

select   EMAIL_PROVIDER  which provider sends: resend, smtp or log
config?  EMAIL_FROM      the From address when a message names none
email.send/1.0.0/
  function.fune
  README.md
  contracts.json                   the contract tests
  impl/typescript.ts               the interface: checks, then calls the chosen provider
  adapters/typescript/resend.ts    one adapter per provider
  adapters/typescript/smtp.ts
  adapters/typescript/log.ts

The manifest is function.fune format 1.1, which starts with format 1.1 so an older fune never misreads it. async yes under a fn line makes it return a promise. An integration says nothing about pure, deterministic or network: it does I/O by definition. Integrations are TypeScript today.

funeio, the one door

All of an integration’s I/O goes through funeio: io().env(), io().http(), io().connect(), io().now(), io().randomBytes() and io().log(). fune build writes it beside the built code as .fune/build/funeio.ts. The integration’s own files are linted as pure code (no fetch, process, clock, randomness, console or timers of their own), so the seam is the only door, and what the contract tests cover is everything it does to the world. Your own tests can replace it the same way, with setIo().

Contract tests

Every rule for vectors holds (at least 8 per function, an error case for each that throws), and a case may also name its provider, its env (declared names only, fake values), now, random bytes, the exchanges it expects in order, and the logs it writes. Every provider needs at least 2 cases, and every function that does I/O a case through each provider. A request that differs from the recording, or a recorded exchange never made, fails the case whatever the integration did with the error. The registry refuses a package that holds anything like a live credential.

{ "name": "resend: posts the message and returns Resend's id",
  "provider": "resend",
  "env": { "RESEND_API_KEY": "re_test_123456789", "EMAIL_FROM": "Acme <hello@acme.example>" },
  "args": [{ "to": ["grace@example.com"], "subject": "Welcome", "text": "Welcome to Acme" }],
  "exchanges": [{
    "request": { "method": "POST", "url": "https://api.resend.com/emails",
                 "headers": { "authorization": "Bearer re_test_123456789" },
                 "json": { "from": "Acme <hello@acme.example>", "to": ["grace@example.com"], "subject": "Welcome", "text": "Welcome to Acme" } },
    "response": { "status": 200, "json": { "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" } } }],
  "expect": { "provider": "resend", "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" } }

Contract tests prove the integration speaks the protocol as recorded and handles what the service answers. They do not reach the service: send one real request from staging before going live.

In a project: .env.example and fune secrets

import { sendEmail } from "#fune/email.send@^1";

await sendEmail({ to: ["ada@example.com"], subject: "Welcome", text: "Hello Ada" });
  • fune build builds it like any capability, writes funeio.ts, and writes .fune/build/.env.example: every variable the build’s integrations read, grouped by provider, with what each is. No values. The built file’s header names its providers, secrets and config.
  • fune secrets lists them and whether each is set, in the environment or in .env and .env.local. It never prints a value. fune secrets --check exits 1 when a required one is missing: put it in a deploy step.
  • fune verify runs the contract tests against the build, offline.
  • fune new <namespace>.<name> --integration starts one of your own: a working example with two providers and its contract tests, which validates and verifies as written.
  • A project refuses every integration with policy allow-integrations false. allow-network false is about functions: an integration is named by the project and fenced in funeio, so it is governed by its own key.
  • An integration may require functions and other integrations; a function may never require an integration, so pure code stays pure all the way down.

Browse them at Integrations, or search with kind=integration (/v1/search?q=email&kind=integration). The full format is spec/integration-file-format.md in the repository.

13

Use Functional Weave from AI tools

A coding agent about to write a function should look here first: if a capability fits, the project gets one line and tested code instead of new code to review. Three things make that the agent’s habit.

The MCP server

This registry is an MCP server at http://www.functionalweave.com/mcp: Streamable HTTP, stateless, read-only, and open without an account. Its tools are plan_app (call it first when someone describes an app to build: the suite for that kind of app, in build order, and the gaps), search_functions (call it before writing a function), get_function (signatures, worked examples, status, license, the one-line reference and the hooks), get_source, list_categories, get_suite and list_suites, with a find-or-write prompt. fune mcp is the same server on stdio, run inside a project: it reads the project’s own registry (a directory works offline) and adds project_info, add_function, add_suite and check_project.

Claude Code:

# the registry, remote (read-only, no account needed)
claude mcp add --transport http fune http://www.functionalweave.com/mcp

# or the local server, inside a project: its registry, its language, and
# project_info, add_function and check_project as well
claude mcp add fune-local -- fune mcp

Cursor and VS Code, in the project:

// .cursor/mcp.json
{
  "mcpServers": {
    "fune": { "url": "http://www.functionalweave.com/mcp" },
    "fune-local": { "command": "fune", "args": ["mcp", "--project", "${workspaceFolder}"] }
  }
}
// .vscode/mcp.json
{
  "servers": {
    "fune": { "type": "http", "url": "http://www.functionalweave.com/mcp" },
    "fune-local": { "type": "stdio", "command": "fune", "args": ["mcp", "--project", "${workspaceFolder}"] }
  }
}

The agent skill

The repository’s ai/skills/fune/ is an Agent Skill (Claude Code and other tools that read SKILL.md). It triggers whenever the agent is about to implement a function, calculation, validation, formatting or business rule, and walks it through search, read, use or write. Copy the folder into .claude/skills/ in a project, or ~/.claude/skills/ for every project. Without a skill, paste this into the project’s AGENTS.md or CLAUDE.md:

## Functions: search Functional Weave first

When the user describes an app to build, call the Functional Weave MCP server's plan_app
first (or `fune search "<description>"` and `fune suite <id>`) and show
them what Functional Weave covers and the gaps you will write.

Before writing a utility, calculation, validation, formatting rule or piece of
business logic, search Functional Weave (its MCP server's search_functions, or
`fune search <words>`). If a capability fits, use its one-line reference in
the file that calls it and run `fune build`; never copy its code or edit
.fune/build. Customise one with a hook, not a fork. Tell the user before
relying on one whose status is unreviewed. If nothing fits, write it yourself.

llms.txt

/llms.txt is the registry in brief, for a model reading the site; /llms-full.txt is every published capability on one line, with its signatures and status.

14

Keeping a project current and safe

Three commands, for a person or a maintainer agent, all reading the project’s fune.lock:

fune outdated            # current, wanted (in range), latest; patch, minor or major; yanked, deprecated, advisories
fune update              # take every move the ranges allow, and rebuild
fune update <id> --major  # cross a major: lists what changes for a caller, moves the range, rebuilds
fune audit               # advisories, yanks and deprecations: exit 0 clean, 1 findings, 2 could not check

Each takes --json. fune audit --level high fails only on high and critical findings; a yanked version counts as high and a deprecated one as info. The same answer for any lock, in one request: POST http://www.functionalweave.com/v1/check with the lockfile as the body; its entries give each locked function on one row, with whether it is outdated or yanked, the advisories against it, its licence, and its signature status (signed, by which key, and whether that is still the signature the lock recorded). fune serve answers it too, from a registry directory. Over MCP it is check_updates (inside fune mcp it reads the project’s lock), with list_advisories beside it.

Advisories

An advisory is a security or correctness notice against a range of one function’s versions, with a stable id (FWA-2026-0001), a severity (low, moderate, high, critical), a summary, details, the affected range and the range that fixes it, and references. The organisation that owns the function writes one from its page (Write an advisory) or with POST /v1/advisories; a registry administrator reviews it before it is published. Published, it is a banner on every affected version’s page, in /advisories, in /index.json (and so in every fune audit), in the feed and in webhooks. To stop a version spreading at once, yank it as well: that needs no review.

The feed

Everything that happens to published functions, in order: new versions, deprecations, yanks, advisories and suites.

GET /v1/feed?since=<cursor>&limit=50&type=advisory.published,version.yanked
GET /v1/capabilities/<id>/feed      GET /v1/namespaces/<namespace>/feed
GET /v1/feed.atom                    (and .atom on each of the above)

The JSON reads forwards: keep the next it returns and ask from there next time (since=0 is the beginning). Atom reads backwards, newest first, with a next link into the past.

Webhooks

An organisation’s admins add webhooks on its Webhooks page; anyone can add their own under settings. One is an https address and the events it wants: new versions, yanks and deprecations, advisories and suites, of what the organisation owns, of what its functions depend on, and of anything it lists to watch (money.amount, money.*, suite:accounting); plus the verdict on its own uploads (verified, rejected, waiting for review). Private, loopback and cloud-metadata addresses are refused.

Each delivery is a POST of the event as JSON with x-fune-event, x-fune-event-id (dedupe on it), x-fune-delivery, x-fune-timestamp and x-fune-signature: sha256=<hex>, the HMAC-SHA256 of <timestamp>.<body> with the secret shown when you created it. Check it over the raw body and refuse a timestamp more than five minutes old:

import { createHmac, timingSafeEqual } from 'node:crypto';

// raw: the request body exactly as received, before JSON.parse.
function verify(secret, headers, raw) {
  const ts = headers['x-fune-timestamp'];
  if (!/^\d+$/.test(ts) || Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;
  const want = Buffer.from('sha256=' + createHmac('sha256', secret).update(ts + '.').update(raw).digest('hex'));
  const got = Buffer.from(String(headers['x-fune-signature'] || ''));
  return want.length === got.length && timingSafeEqual(want, got);
}

Answer any 2xx. Anything else, a redirect included, is retried after 1 minute, 5, 30, 2 hours, 8 and 24, then given up; every attempt is in the webhook’s delivery log, with a Redeliver button. After 20 failures in a row the webhook is disabled until you enable it again.

A program registers its own with a token: POST /v1/webhooks with {"url", "events", "watch"} (a personal token’s are yours; add ?org=<name> for an organisation’s you administer; an organisation’s service token with the read scope manages that organisation’s), GET /v1/webhooks, DELETE /v1/webhooks/<id>. Events take wildcards (advisory.*); the secret is generated unless you send one, and shown once. POST /v1/webhooks/<id>/rotate-secret issues a new one and keeps the old one signing for a grace window (a day unless you send graceSeconds): meanwhile x-fune-signature is the new secret’s and x-fune-signatures lists both, sha256=<new>, sha256=<old>, so accept a delivery when any entry matches.

Licence notices for a lock

What the licences of the functions you ship ask of you, for exactly the versions in a lock: each version’s licence, its copyright lines and its NOTICE file (a ported library’s notice, an Open Government Licence attribution statement), then each licence once, in full where it has a text to give (Apache-2.0, MIT). Ship the text with your product. fune build writes the same to .fune/build/NOTICES; fune notices prints it for fune.lock (--out NOTICES, --json).

POST http://www.functionalweave.com/v1/notices                     the fune.lock (or {"lock": ...}) as the body
GET  http://www.functionalweave.com/v1/notices?lock=money.amount@1.0.2,math.atan@1.0.1
     ?format=text (or Accept: text/plain)   the NOTICES text alone

The JSON is { format: "fune-notices/1", complete, gaps, entries, missing, licenses, text }: each entry’s license, notice, copyright lines and any attribution added (OGL’s default statement, for data whose package gives none), and each licence’s attributionRequired, requires and whether its fullText is included. complete is false, with each reason in gaps, when a locked version is not published here, states no licence, or names a licence fune does not know. No token is needed; with one, your organisation’s private functions are included. A malformed lock is a 400; more than 60 requests a minute from one address, a 429.

Mirrors

A read-only copy of this registry in your own infrastructure keeps builds working when this one is down. fune mirror sync --from http://www.functionalweave.com --to gs://<bucket> (or a directory) copies the index, every package, the keys, the release log, verification reports, suites and advisories, and checks every signature, every package, the log’s hash chain and its signed head against the keys pinned in fune, refusing a rollback; anything that fails publishes nothing. fune mirror serve answers the same read routes in the same shapes (and POST /v1/check), refusing every write. Point a project at it, keeping the origin’s keys:

format     1.1
registry   https://mirror.example.com
mirror-of  http://www.functionalweave.com            # or FUNE_MIRROR_OF; registry-fallback <url> fails over instead

A Cloud Run job, a bucket and a scale-to-zero service cost cents a month: infra/mirror/deploy.sh prints the plan. The details are in spec/registry-mirror.md.

15

Registry readiness

Whether to trust the registry, in one public read: GET http://www.functionalweave.com/v1/readiness. No sign-in; the answer may be a minute old.

{
  "reverify": { "outcome": "ok", "green": true, "startedAt": "…", "durationMs": 444671,
                "counts": { "registryVersions": 660, "verified": 606, "grandfathered": 54, "drifted": 0, "notRun": 0, … },
                "drifted": [], "runner": { "image": "…", "imageId": "sha256:…", "toolchains": { "node": "…", "rustc": "…" } }, … },
  "signing":  { "keyId": "fw-…", "versions": 660, "signed": 660, "signedShare": 1, "signedByActiveKey": 660, "activeShare": 1, "keys": [ … ] },
  "search":   { "recordedAt": "…", "target": "…", "modes": [ { "name": "hybrid", "recall1": 0.96, "recall5": 1, "recall10": 1, "mrr": 0.98,
                "latencyMs": { "p50": 40, "p95": 60 }, … } ] }
}
  • reverify: the last nightly re-verification of every registry version in the sandbox, with the runner image production verifies uploads with. outcome is ok, drift (a version no longer verifies, or its contents no longer hash to their recorded integrity; drifted lists them) or error (the run did not happen; reason says why). grandfathered versions were published before a newer rule and still pass their vectors. null until the first run is reported.
  • signing: counted live. The active release-signing key (/.well-known/fune-keys.json), and how many public published versions carry a signature from a key that still verifies (active or retired, not revoked), and from the active key.
  • search: the last recorded search benchmark over the registry's query set: recall@1/5/10 and MRR over the scored queries, and the client-measured latency, per search mode, with where it was measured (target, note). null until one is reported.

The nightly build posts the two reports to POST /internal/readiness/reverify and /internal/readiness/search with Authorization: Bearer and the operator's readiness secret; they are not for anyone else.

16

The registry API

Everything the CLI and the website do is a JSON API under http://www.functionalweave.com/v1/. Errors are {"error": "…"} with the status saying what kind (400 the request, 401 no token, 403 not allowed, 404 not there or not yours to see, 422 a capability that does not validate, 429 slow down: retry-after; see rate limits). Tokens go in authorization: Bearer …; nothing that changes anything takes a cookie. Answers only ever gain fields.

RouteAuthWhat
GET /v1/versionnoneWhich registry build this is (version, schema, features), to check before relying on a route.
GET /index.jsonnoneThe catalogue a CLI resolves against: versions, integrity, licences, signatures, advisories.
GET /.well-known/fune-keys.jsonnoneThe release-signing public keys.
GET /v1/search?q=noneRanked search, with one-line references and matching suites.
GET /v1/suites, /v1/suites/<id>noneSuites, and one resolved in a language.
POST /v1/plan_appnoneAn app description in; the matching suites, sections in build order (each capability’s version, licence, status, level, signature and one-line import) and the gaps out. The MCP tool’s answer.
GET /v1/capabilities/<id>noneIts published versions.
GET /v1/capabilities/<id>/versions/<v>/verificationnone (private: its organisation)Who verified it and when, tests passed, failed and declared per language, the sandbox run, integrity, signature; then the full report.
GET /v1/lognoneThe transparency log of signed releases.
GET /v1/feed[.atom]noneRegistry events from a cursor.
GET /v1/advisoriesnoneAdvisories in force; capability=, namespace=, since=, withdrawn=1.
POST /v1/checknoneA fune.lock in: outdated, yanked, advisories, licence and signature status per entry.
POST /v1/notices, GET /v1/notices?lock=noneThe licence NOTICES for exactly the versions in a lock.
GET /v1/readinessnoneThe last nightly re-verify, signing coverage and the last search benchmark.
POST, GET /v1/webhooks; DELETE /v1/webhooks/<id>; POST …/rotate-secrettokenWebhooks registered by a program.
POST /v1/advisories (and /<id>, /review, /withdraw)personal tokenWrite and review advisories.
POST /v1/publish, GET …/<v>/status, POST /v1/yanktoken with publishPublish, follow and yank versions.
POST /v1/suites, DELETE /v1/suites/<id>token with suitesPublish and remove suites.
POST /v1/login, /v1/login/device[/token]; GET /v1/whoaminone / tokenGet a token; who it is.
GET, POST /v1/orgs/<org>/tokens; DELETE …/<id>an admin’s personal token, or its partnerOrganisation service tokens (expires_at).
POST /v1/orgs; GET /v1/orgs/<org>; POST, DELETE …/members; POST …/namespacesa personal token that may publish, or a partner tokenOrganisations, members, invitations and namespaces over the API.
POST /v1/orgs/<org>/capabilities; GET …/versions/<v>/statustoken with publishContribute a capability to the organisation, privately; poll until done.
POST /v1/signals/gaps; GET /v1/signals/gapsnone / registry adminReport how often a suite’s gap is written by hand (counts only); read the top gaps.
POST /mcpnoneThe MCP server.

The reference, with every request, answer, error and auth rule, is spec/registry-api.md in the repository. fune serve answers /v1/version, /v1/advisories and POST /v1/check from a registry directory, in the same shapes; a mirror answers the read routes, POST /v1/check and POST /v1/plan_app, in the same shapes too.