Configuration

The hypermake.json reference

A Hypermake project is declared by one file at the project root: hypermake.json. This page documents every key the loaders actually read — derived from the loader code, not from intent — with its type, default, and which parser reads it. This site's own hypermake.json is used as the primary worked example.

How the file is read

There is no single parser. Three read paths share the file, and they disagree about strictness. This is a real property of the current contract, so the reference states it up front and attributes every key below to its reader.

The three read paths

ReaderStyleOn unknown or invalid keys
Project loader (hyperproject.Config)Typed, lenient. Backs recipes, protocols, daemon policy, capabilities.Unknown top-level keys are silently ignored — a typo like "recipeSource" is inert, not an error. Exceptions that do fail the load: a malformed rootUuid, and invalid privateJobs/hostResources service bindings.
Serve subsection decodersStrict, per-block. dev.responseHeaders, dev.documentShells, dev.auth each get a dedicated decoder with unknown fields disallowed.Any unknown field or malformed entry inside these blocks is a hard error: serve refuses to start.
Serve identity probeFallback-chain scavenger. dev.origin, dev.defaultTarget, dev.transport, dev.inspect are probed as raw paths — in hypermake.json first, then legacy locations in config.json.Unreadable JSON and absent paths are skipped silently; the first value found wins.

Identity and roots

Identity keys — project loader (lenient)

KeyTypeDefaultNotes
idstring""Project identity. The dev service falls back to the root directory's basename when empty. (The serve layer also reads id/name directly, bypassing the typed loader.)
namestring""Display name for registries and service records.
rootUuidstringabsentAuthored project identity: a lowercase RFC 4122 UUID, never derived or normalized by the system. Gates privileged connection/operator operations, which fail closed when it is missing. A malformed value fails every config load — this is the one top-level key the lenient loader validates.
rootMarkersstring[]["hypermake.json", "Hypermakefile", "Makefile", "config.json"]Root-marker filenames projected to capability consumers. Root detection itself always walks up using the default set — it has to find the file before it can read it.
defaultTargetsstring[][]Declared default build targets, projected through the capabilities surface. No build path substitutes them today: a bare build still errors with missing build target. Declare and treat as advisory.
Identity in practice (the hypermake repo's own config) hypermake.json
{
  "id": "hypermake",
  "name": "Hypermake",
  "rootUuid": "8633838b-1e6f-4798-a766-bef5d298cdbc",
  "dev": { "origin": "https://hypermake.localhost", "inspect": true },
  "makeRecipeRoots": ["recipes", "meta/hypermake/src"]
}
		

Recipe sources

Recipe keys — project loader (lenient)

KeyTypeDefaultNotes
recipeSourcesobject[]see notesEach entry: {id, origin, kind, path, handler?, tool?, commands?}. When neither recipeSources nor makeRecipeRoots is declared, src/ and recipes/ are auto-scanned if they contain .make files, and a root recipes.json is auto-registered as a native-spec source.
makeRecipeRootsstring[][]Directories scanned recursively for .make recipe files under origin make. Equivalent to a recipe-dir source; this fixture declares both for the same directory.
phpCompatSourcesstring[][]Legacy compat listing projected to capabilities. Actual compat recipes load through a recipeSources entry of kind compat/php-compat.

recipeSources kinds

kindMeaning
native-spec (also "", pattern-json)A JSON file of declarative pattern-recipe specs at path.
recipe-dirA directory of .make recipe files at path, under this source's origin.
compat / php-compatA PHP-compat recipe file at path.
manifestPattern recipes generated from a manifest file; handler defaults to manifestArtifact, commands defaults to a file-existence check.
lzrThe built-in LZR recipe pack; tool overrides the lzr binary name.
anything elseSilently skipped — a misspelled kind contributes no recipes and no error.

Protocol mappings

protocols (object[], project loader) maps protocol names to project directories: {"name": "public", "dir": "rendered/public"}. When the key is absent the defaults are src, cache, build, rendered, public → rendered/public, and the journal directory. Two names are core-owned and cannot be remapped — declared mappings for journal and request-projection are silently dropped and re-forced to their control directories — and the hypermake name maps to the Hypermake home directory unless the project declares it. See Protocols and addresses for how the mapped names behave; hypermake protocols list prints the effective registry.

This site's mappings hypermake.json (this fixture)
"protocols": [
  { "name": "src", "dir": "src" },
  { "name": "cache", "dir": "cache" },
  { "name": "rendered", "dir": "rendered" },
  { "name": "public", "dir": "rendered/public" }
]
		

Daemon policy

daemon.* — project loader (lenient)

KeyTypeDefaultNotes
daemon.autoStartstring"recommend"One of on-first-command, recommend, off. Any other value falls back to recommend silently.
daemon.idleTTLstring"4h0m0s"Go duration string; idle shutdown TTL for the resident daemon. hypermake daemon status reports the effective policy and its source.

The dev block

Everything the resident dev service needs lives under dev. The four identity keys use the fallback-chain probe; the block-shaped keys each have their own decoder.

Serve identity — fallback-chain probe

KeyTypeDefaultNotes
dev.originstringnoneThe public origin the service answers as, e.g. "https://lzr-testing.localhost". Probe order: --origin flag, then dev.origin and legacy paths in hypermake.json/config.json. Serve errors when nothing resolves.
dev.defaultTargetstring"public"The build target the service serves when none is passed.
dev.transportstring"unix-socket"unix-socket (socket under .hypermake/run/, fronted by a local reverse proxy) or tcp (loopback --addr).
dev.inspectboolfalseEnables the Inspector surface. Also forced on by the --inspect flag or a *.localhost origin host.

Serve blocks — strict decoders (unknown fields are errors)

KeyTypeDefaultNotes
dev.responseHeadersobject[][]Each entry {path, set}: an exact URL path and a header-name→value object. Duplicate paths, duplicate header names (case-insensitive), non-ASCII values, Caddy placeholder syntax, and the reserved Service-Worker-Allowed header are all rejected.
dev.documentShellsobject[][]Each entry {shell, routePatterns}: an .html shell artifact served for document navigations whose path matches any pattern (* matches one segment). Applies only to requests with a document navigation destination; fragment fetches pass through.
dev.authobjectabsentFail-closed ingress binding for served deployments; shape below.
dev.requestProjectionsobject[][]Each entry {schemaVersion, routePattern, targetPattern, provider, keyPattern} with schema hypermake.request-projection-route.v1. Providers are a closed set (approval-detail, job-detail); targets must be bounded rendered/public/ targets; route captures {name} bind the target and key.
dev.companionsobject[][]Sidecar processes the dev service supervises; schema hypermake.dev-companion.v1. Validated when the service materializes companion artifacts; shape below.
dev.edgeHandlersobject[][]Edge-module declarations, schema hypermake.dev-edge-handler.v1: {id, module, directive, sourceTarget, configTarget, publicFileBinding, placement} with placement fixed to before-routing and a read-only, non-secret file binding.

dev.auth shape

All paths are canonical project-relative references; ingress must be one of application-unix-socket, control-unix-socket, private-probe and must be trusted by the referenced deployment policy, or serve refuses to start. exchangeDirectory and loginRedirects must be declared together. The device block enables the device login flow: the signing key is delivered only through the named environment variable, requestTtlSeconds is 1–600, and sessionTtlSeconds is capped by the deployment policy. Values below are placeholders — mint real policy material with hypermake auth owner-ceremony. Serving with authentication documents the policy files, the ceremony, and the refusal contract in full.

Placeholder shape (not a live configuration) hypermake.json
"dev": {
  "auth": {
    "policy": "auth/example-instance/deployment.json",
    "ingress": "application-unix-socket",
    "projectPolicy": "auth/example-instance/project-policy.json",
    "exchangeDirectory": "auth/example-instance/exchanges",
    "loginRedirects": ["/"],
    "device": {
      "signerPrivateKeyEnvironment": "EXAMPLE_DEVICE_SIGNER_KEY_FILE",
      "requestTtlSeconds": 120,
      "sessionTtlSeconds": 43200
    }
  }
}
		

dev.companions and hostResources

A companion declares an executable graph target, argv, and health probe; transport is unix-socket only, health exposure is private-control only, and routePrefix may not overlap another companion or the reserved /_hypermake and /lzr-runtime owners. Argv may not embed absolute paths or secret-shaped values; host access goes through declared placeholders: ${socket}, ${origin}, ${root}, and ${host:NAME} for a binding declared in top-level hostResources. Host resource kinds are a closed set: directory (read|read-write/private-path), file (read/private-path), credential-file (read/secret-material), unix-socket (connect/owner-socket).

Worked example (from the in-tree dev-companion fixture) hypermake.json
"hostResources": [
  { "name": "fixture-corpus-root", "kind": "directory", "access": "read-write", "handling": "private-path" },
  { "name": "fixture-corpus-key", "kind": "credential-file", "access": "read", "handling": "secret-material" }
],
"dev": {
  "companions": [
    {
      "schemaVersion": "hypermake.dev-companion.v1",
      "id": "corpus-fixture",
      "executableTarget": "cache://runtime/fixture-server",
      "argv": ["--mode", "corpus", "--listen", "${socket}",
               "--root", "${host:fixture-corpus-root}",
               "--key-file", "${host:fixture-corpus-key}"],
      "transport": "unix-socket",
      "routePrefix": "/_fixture/corpus",
      "bindings": ["fixture-corpus-root", "fixture-corpus-key"],
      "health": { "path": "/health", "exposure": "private-control",
                  "timeoutMs": 250, "retryWindowMs": 3000 }
    }
  ]
}
		

Action packs

actionPacks (object[], project loader) declares digest-locked project code with a declared effect surface. Entry shape: {id, kind, manifest, sourceRoots, modulePath, package?, buildTags?, targetOS?, targetArch?, wasmTarget?, hostABI?, sdkVersion, actions, capabilities?, metadata?}; each action carries {name, version, handler?, effects, capabilities}. Effects come from a fixed vocabulary: path.read, path.write, data.mutate, target.write, process.execute, network.publish, browser.host-call, diagnostic.emit, metric.record, sync.enqueue. Capabilities scope those effects to concrete paths, dataPaths, targets, or hostCalls. This site declares one browser-wasm pack:

This site's action pack (abridged) hypermake.json (this fixture)
"actionPacks": [
  {
    "id": "lzr-testing-admin",
    "kind": "browser-wasm",
    "manifest": "hypermake/browser-action-pack.json",
    "sourceRoots": ["hypermake/browser-actions"],
    "modulePath": "hypermake.local/lzr-testing/browser-actions",
    "wasmTarget": "hypermake.local/lzr-testing/browser-actions",
    "hostABI": "hypermake.browser-action-host.v0",
    "sdkVersion": "hypermake.actionpack.v0",
    "actions": [
      {
        "name": "lzr-testing/admin/update-campaign-title",
        "version": "v1",
        "effects": ["path.read", "path.write", "data.mutate",
                    "browser.host-call", "sync.enqueue"],
        "capabilities": [
          { "kind": "data.mutate", "dataPaths": ["data://campaign.json#/title"] },
          { "kind": "browser.host-call",
            "hostCalls": ["runtime.data.read", "runtime.data.patch"] }
        ]
      }
    ]
  }
]
		

Client graph

clientGraph.* — client-graph packager (lenient envelope, validated entries)

KeyTypeDefaultNotes
clientGraph.writableResourcesobject[][]{name, dataTarget, adapterTarget?, operation?, patchPointer?, patchOp?, initialGeneration?, initialValue?} — named browser-writable resources, e.g. {"name": "demo.save", "dataTarget": "client://demo/status.json"}.
clientGraph.clientProtocolsobject[][]{protocol, patterns?, sensitivity, resources} — browser-owned protocol families with per-resource kinds and default values.
clientGraph.pipelineobjectabsentA client pipeline graph; normalized and validated when packaging, with diagnostics on invalid shapes.
clientGraph.modelPacksobject[][]{id, manifestDigest, manifestUrl} references to digest-pinned model packs.
clientGraph.routeOwnersstring[]key absentAuthoritative owner set for route-manifest completeness. Presence matters: an empty list explicitly opts out of enforcement; an absent key derives owners from self-declaring src/!owner route dirs.
clientGraph.staticNavigationRoutesstring[]key absentExplicit opt-in per fixed route to static navigation serving; each entry must name exactly one built owned route. Never inferred.

Appendix: remaining keys

Lower-traffic keys — project loader (lenient)

KeyTypeNotes
privateJobsobject[]Private-job provider declarations (subject prefixes, executor targets, service bindings). Normalized and validated at parse time — the one array that can fail the lenient load, including its hostResources service bindings.
toolsobject[]External tool declarations: {id, kind, program, path?, versionCommand?, fingerprintPolicy, effects}.
discoveryobject[]Discovery providers: {id, kind, path?, handler?, inputs, outputs, effects, cachePolicy, proof}.
validationSuites / benchmarkSuitesobject[]Named target-list suites: {id, kind, path}, consumed by validate and benchmark commands.
compatibilityobject[]Compat module inventory with owners, reasons, replacements, and retirement triggers per handler.
graphicsManifeststringPath to a graphics corpus manifest for the graphics command family.
Verify this yourself shell
hypermake doctor
hypermake protocols list
hypermake daemon status
hypermake resolve src://docs/hypermake-json.html