builder

type BuildCache struct {
	// contains filtered or unexported fields
}

type BuildConfig struct {
	Lang       string   `toml:"lang"`
	Entrypoint string   `toml:"entrypoint"`
	Args       []string `toml:"args"`
	// Run lists shell commands to execute before the language driver packages the project.
	// Equivalent to RUN instructions in a Dockerfile — use for build steps like
	// "npm run build", "nuxt build", "python manage.py collectstatic", etc.
	Run []string `toml:"run"`
	// DiskSize sets the minimum image file size passed to mkfs (e.g. "512M", "1G").
	// Use when the default content-based image size leaves insufficient free space
	// for runtime writes (e.g. database temp tablespaces, log files).
	DiskSize string `toml:"disk_size"`
	// Dirs lists absolute directories to create (empty) inside the image —
	// analogous to a Dockerfile's mkdir/VOLUME. Use for volume mount points (a
	// TFS volume can only be mounted onto a directory that already exists in the
	// root image) and for scratch paths the program writes to at runtime.
	Dirs []string `toml:"dirs"`
}

type BuildResult struct {
	// BinaryPath is the path to the compiled ELF binary.
	// For interpreted languages (Node, Python), this may be empty and
	// SourceDir should be used instead.
	BinaryPath string
	// SourceDir is the directory containing the application source files
	// to include in the image (used for interpreted languages).
	SourceDir string
	// Entrypoint is the command or script that should be used as the program entrypoint.
	Entrypoint string
	// Packages lists language runtime packages that should be included in the image
	// (e.g. "node:20" for Node.js projects).
	Packages []string
	// Env holds runtime environment variables required by this build (e.g. PYTHONPATH
	// when pip installed packages into a non-default directory).
	Env map[string]string
}

type CacheEntry struct {
	Key         string `json:"key"`
	ImageDigest string `json:"image_digest"`
	SourceDir   string `json:"source_dir"`
	Lang        string `json:"lang"`
}

type Config struct {
	Build   BuildConfig   `toml:"build"`
	Run     RunConfig     `toml:"run"`
	Env     EnvConfig     `toml:"env"`
	Program ProgramConfig `toml:"program"`
	Stages  []StageConfig `toml:"stages"`
}

type CopyFromConfig struct {
	// Stage is the name of the source stage.
	Stage string `toml:"stage"`
	// Src is the file path within the source stage's build output.
	Src string `toml:"src"`
	// Dst is the destination path in the current stage (defaults to Src basename).
	Dst string `toml:"dst"`
}

type Driver interface {
	// Detect checks whether the given directory contains a project of this language.
	// Returns true if the language markers are found.
	Detect(dir string) bool

	// Build compiles the project in dir and returns the path to the resulting binary.
	Build(ctx context.Context, dir string, opts Options) (BuildResult, error)

	// Lang returns the language this driver builds.
	Lang() Lang
}

type EnvConfig map[string]string

type GoDriver struct{}

type IgnoreMatcher struct {
	// contains filtered or unexported fields
}

type Lang int

type NodeDriver struct{}

type Options struct {
	// Entrypoint overrides the default entrypoint for the language (e.g. "cmd/server/main.go" for Go).
	Entrypoint string
	// BuildArgs are extra arguments passed to the language build tool.
	BuildArgs []string
	// Env is additional environment variables for the build process.
	Env []string
	// PkgFiles are pre-resolved package file paths to include in the image.
	PkgFiles []string
	// Platform is the target platform for cross-compilation. Defaults to the current platform.
	Platform Platform
	// Output is where subprocess output (compiler, package manager, etc.) is written.
	// If nil, defaults to os.Stderr.
	Output io.Writer
}

type Platform struct {
	OS   string
	Arch string
}

type ProgramConfig struct {
	Path string   `toml:"path"`
	Args []string `toml:"args"`
}

type PythonDriver struct{}

type RawDriver struct{}

type RunConfig struct {
	Memory string   `toml:"memory"`
	CPUs   int      `toml:"cpus"`
	Ports  []string `toml:"ports"`
}

type RustDriver struct{}

type StageConfig struct {
	// Name is the stage identifier (required). Referenced by CopyFrom.
	Name string `toml:"name"`
	// Lang is the build language for this stage (e.g. "go", "node").
	Lang string `toml:"lang"`
	// Entrypoint overrides the default entrypoint for the language.
	Entrypoint string `toml:"entrypoint"`
	// Args are extra arguments passed to the build tool.
	Args []string `toml:"args"`
	// CopyFrom lists artifacts to copy from other stages.
	CopyFrom []CopyFromConfig `toml:"copy_from"`
}