lockfile

type ConfigWeight struct {
	Name    string
	URI     string
	Target  string
	Include []string
	Exclude []string
}

type DriftKind string

type DriftResult struct {
	Name    string
	Kind    DriftKind
	Details string // human-readable detail, e.g. "target: /old → /new"
}

type RuntimeWeightEntry struct {
	Name      string `json:"name"`
	Target    string `json:"target"`
	SetDigest string `json:"setDigest"`
}

type RuntimeWeightsManifest struct {
	Weights []RuntimeWeightEntry `json:"weights"`
}

type WeightLockEntry struct {
	// Name is the weight's logical name (e.g. "z-image-turbo").
	Name string `json:"name"`
	// Target is the container mount path for this weight.
	Target string `json:"target"`
	// Source records where the weight came from and how it was filtered.
	Source WeightLockSource `json:"source"`
	// Digest is the sha256 digest of the assembled OCI manifest.
	Digest string `json:"digest"`
	// SetDigest is the weight set digest (spec §2.4): a content-addressable
	// identifier for the file set, independent of packing strategy.
	SetDigest string `json:"setDigest"`
	// Size is the total uncompressed size of all files in bytes (sum of
	// layer sizeUncompressed).
	Size int64 `json:"size"`
	// SizeCompressed is the total compressed layer size in bytes (sum of
	// layer size) — the bytes the registry stores.
	SizeCompressed int64 `json:"sizeCompressed"`
	// Files is the per-file index, sorted by path. Each entry records the
	// file's size, content digest, and which layer contains it.
	Files []WeightLockFile `json:"files"`
	// Layers is the set of packed tar layers, sorted by digest. Layer
	// emission order from the packer is not guaranteed stable (future
	// concurrency) — sorting produces deterministic output.
	Layers []WeightLockLayer `json:"layers"`
}

type WeightLockFile struct {
	// Path is the file path relative to the weight source directory,
	// with forward slashes regardless of host OS.
	Path string `json:"path"`
	// Size is the file's uncompressed size in bytes.
	Size int64 `json:"size"`
	// Digest is the sha256 content digest of the file (hex-encoded with
	// the "sha256:" prefix).
	Digest string `json:"digest"`
	// Layer is the digest of the layer containing this file.
	Layer string `json:"layer"`
}

type WeightLockLayer struct {
	// Digest is the sha256 digest of the layer blob.
	Digest string `json:"digest"`
	// MediaType is the OCI layer media type
	// (application/vnd.oci.image.layer.v1.tar or .tar+gzip).
	MediaType string `json:"mediaType"`
	// Size is the size of the layer blob in bytes (the bytes the
	// registry stores, post-compression for gzip layers).
	Size int64 `json:"size"`
	// SizeUncompressed is the sum of regular-file bytes in the layer,
	// matching the definition used for run.cog.weight.size.uncompressed
	// on index descriptors.
	SizeUncompressed int64 `json:"sizeUncompressed"`
}

type WeightLockSource struct {
	// URI is the normalized source URI (e.g. file://./weights,
	// hf://org/model, s3://bucket/prefix/).
	URI string `json:"uri"`
	// Fingerprint is the source's version identity at import time.
	// Scheme-prefixed (sha256:, commit:, etag:, …).
	Fingerprint weightsource.Fingerprint `json:"fingerprint"`
	// Include is the sorted list of glob-style include patterns applied
	// to the source. Sorted because order is not semantically meaningful
	// (the patterns are a set, not a sequence) and canonicalizing here
	// keeps the lockfile stable across reorderings in cog.yaml. Empty
	// patterns are serialized as [] so the shape is stable.
	Include []string `json:"include"`
	// Exclude is the sorted list of exclude patterns, same shape as Include.
	Exclude []string `json:"exclude"`
	// ImportedAt is the wall-clock time of the import that produced this
	// entry. It is informational only — it never participates in
	// equality checks (see EntriesEqual).
	ImportedAt time.Time `json:"importedAt"`
}

type WeightsLock struct {
	Version int `json:"version"`
	// EnvelopeFormat is the sha256 digest (with "sha256:" prefix)
	// identifying the packer configuration that produced — or, on
	// the next import, will produce — the recorded layer digests.
	//
	// Cog stamps the current envelope digest into the lockfile on
	// every rewrite. On a subsequent import a mismatch (including a
	// missing/empty value, treated as "no match") forces the builder
	// to recompute layer digests from the local content store
	// instead of trusting the cached entry. See
	// pkg/model/envelope.go for what feeds into the digest.
	//
	// Empty when the lockfile has never been written by a
	// version of cog that knows about this field — that empty
	// value compares unequal to any current envelope digest, which
	// is exactly the "force a recompute" behavior we want.
	EnvelopeFormat string            `json:"envelopeFormat"`
	Weights        []WeightLockEntry `json:"weights"`
}