Glossary

Glossary

Terminology used across the Tamp project. Cross-referenced with the page that explains each in depth.

Core concepts

Target — a unit of work in a build. Declared as a property of type Target on a class deriving from TampBuild. Has dependencies, conditions, an action body, and assorted scheduling hints. (Build Script Authoring)

TargetSpec — the immutable record produced from a Target property's fluent chain. The executor consumes specs; the mutable builder is gone by the time execution starts.

Plan — a CommandPlan. The frozen description of a child process to spawn: executable, arguments, environment, working directory, optional stdin, registered secrets. Tool wrappers produce plans; the runner dispatches them.

Phase — a lifecycle bucket attached to a target: Restore, Build, Test, Pack, Publish, Deploy, Custom. Used for grouping in build summaries; also a hint for default scheduling.

Resource — declarative resource consumption marker. Resource.BuildCache.Dotnet, Resource.Network.Internet, Resource.Filesystem(path), etc. Targets that share an exclusive resource serialize.

ConsumeMode — Shared or Exclusive. Pairs with Resource on Consumes(...) calls.

RunMode — Always (default), WhenInputsChanged, or Manual. When the executor decides whether a target runs.

FailureMode — what happens when a target fails: Fatal (default; abort build), Continue, Retry. (Failure Handling)

Failure semantics

OnlyWhen — silent skip if a predicate returns false. Use for "this target is irrelevant in this context."

Requires — abort the build if a predicate returns false. Use for "this target cannot run without X."

OnFailureOf — catch handler. Runs only when one of the named targets fails. Tamp-specific; NUKE doesn't have this.

AssuredAfterFailure — cleanup target that always runs, whether the build succeeded or failed.

DSL edges

DependsOn — pulls a target into the plan and orders before this one.

Before / After — order constraint when both targets are in the plan; does not pull either in.

Triggers / TriggeredBy — fan-out. If this target runs, the named targets also run (or vice versa).

Internal — opt-in marker (1.1.0+) hiding a target from default --list output and IDE runner menus. The target stays invokable by name and surfaces under --list --all. Replaces the obsolete TopLevel() marker — every target is top-level by default now.

Default — opt-in marker (1.1.0+) naming a target as the no-args entry point. One per build class; if none, the executor falls back to a property literally named Default, then Ci.

Modules and wrappers

Module — an independently-versioned NuGet package that wraps a single tool family. Examples: Tamp.NetCli.V10, Tamp.Docker.V27. Each has a single static class (DotNet, Docker) with one method per tool verb. (Module Catalog)

Wrapper — colloquial synonym for "the static class inside a module" — DotNet.Build, Docker.Push. Each wrapper method returns a CommandPlan. As of 1.2.0 every wrapper exposes both a fluent Action<TSettings> configurer overload and an object-init TSettings overload; both produce identical plans.

Tool — a resolved tool reference: an executable path plus working directory. Returned by [NuGetPackage] attributes; also constructible by hand. Tool.Plan(args) produces a CommandPlan from a tool reference.

Injection attributes

[Parameter] — auto-bind a property from CLI args, env vars, or default value (in that precedence). Configuration data, not secrets.

[Secret] — auto-bind a Secret from CI vendor / local store / env var. Sensitive; redacted from logs.

ValueInjectionAttribute — base class for attributes that compute and inject a value at build start. Built-in subclasses: [Solution], [GitRepository], [NuGetPackage]. Build-script-author extensibility point.

Execution and observability

Executor — runs a TargetGraph in topological order. Sequential in v0; the resource scheduler / parallel runner is on the v0.x track.

TargetGraph — frozen graph constructed from the target collection. Validates references, detects cycles, computes execution orders for one or more invoked targets, expands trigger fan-out until stable.

RedactionTable — per-build-invocation registry mapping secret values to placeholder tokens. Updated as each CommandPlan is dispatched; consulted on every write through the executor's writer.

RedactingTextWriter — TextWriter wrapper that scrubs every line through a RedactionTable before passing to the inner writer. Per-line buffered so values split across writes redact correctly.

LogLevel — Trace / Debug / Info / Warn / Error. Filters what reaches the writer. (Logging & Verbosity)

CiHost — typed adapter for the active CI vendor. GitHubActionsHost, AzureDevOpsHost, TeamCityHost today. Auto-resolved via TampBuild.CiHost. (CI Host Integrations)

HostProfile — frozen snapshot of the machine Tamp is running on: OS family, architecture, CPU/memory, container/WSL status, cgroup limits, CI vendor, per-OS info. Built once at startup.

Tooling primitives

AbsolutePath — first-class normalised absolute path. / operator for combining; methods for read/write/glob/hash/copy/move. (Tooling Primitives)

RootDirectory — the consumer repository's root. Resolved by walking up looking for .git, .tamp, or a solution file.

TemporaryDirectory — RootDirectory / .tamp / temp. Tamp's per-build scratch space.

Verify — runtime preconditions for build scripts (Verify.NotNull, Verify.True, etc.). Throws InvalidOperationException with the captured expression text on failure.

Project-level

ADR — Architecture Decision Record. Markdown file under docs/adr/ recording a load-bearing design choice. Append-only after acceptance; revision is via a successor ADR that supersedes the old one.

Module catalog — the set of modules currently published. Today: Tamp.NetCli.V8, V9, V10, Tamp.Docker.V27. The catalog grows as new modules ship.

Version-pinning convention — Tamp.{Family}.V{Major} when the wrapped tool's CLI surface breaks across majors; Tamp.{Family} (unpinned) when the surface is stable. Decided in ADR 0002.

v0 walking skeleton — the minimum credible Tamp surface that a real consumer build can be written against. Functionally complete as of 0.0.1-alpha.

See also

• FAQ — questions about the project as a whole
• Module Catalog — current published modules
• Build Script Authoring — concepts in worked-example form