toolcatalog

package
v0.0.0-...-43e0272 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 14, 2026 License: MIT Imports: 30 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ToolRecordSchemaV1                                  = portabletool.ToolRecordSchemaV1
	ReleaseManifestSchemaV1                             = portabletool.ReleaseManifestSchemaV1
	ReleaseContractSchemaV1                             = portabletool.ReleaseContractSchemaV1
	TargetRecordSchemaV1                                = portabletool.TargetRecordSchemaV1
	BindingContractSchemaV1                             = portabletool.BindingContractSchemaV1
	BindingArtifactSchemaV1                             = portabletool.BindingArtifactSchemaV1
	PayloadRecordSchemaV1                               = portabletool.PayloadRecordSchemaV1
	ArtifactSourceRecordSchemaV1                        = portabletool.ArtifactSourceRecordSchemaV1
	NativePackageSetSchemaV1                            = portabletool.NativePackageSetSchemaV1
	IntegrationFixtureSchemaV1                          = portabletool.IntegrationFixtureSchemaV1
	ValidationProfileSchemaV1                           = portabletool.ValidationProfileSchemaV1
	ValidationEvidenceSchemaV1                          = portabletool.ValidationEvidenceSchemaV1
	SelectedClosureIdentityV1                           = portabletool.SelectedClosureIdentityV1
	PayloadSymbolicLinkPolicyRejectV1                   = portabletool.PayloadSymbolicLinkPolicyRejectV1
	PayloadSymbolicLinkPolicyMaterializeRegularTargetV1 = portabletool.PayloadSymbolicLinkPolicyMaterializeRegularTargetV1
)
View Source 
const (
	ActiveProviderConstraintsSchemaV1 = "active-provider-constraints-v1"
)

Variables

This section is empty.

Functions

func ClientReployVersionV1 

func ClientReployVersionV1(raw string) (string, error)

ClientReployVersionV1 maps Reploy's release identity to the semantic release coordinate that contract `supported_reploy` constraints are written against. A development or pre-release build carries the capabilities of the release it is building toward, so its suffix is dropped rather than treated as a semantic prerelease that no constraint would admit.

func CompilePortableToolPlanV1 

func CompilePortableToolPlanV1(closures []SelectedClosureV1) (providers.PortableToolPlanV1, error)

CompilePortableToolPlanV1 projects selected catalog closures into the provider-neutral plan consumed by provider planning. The compiler owns the projection boundary: catalog record structs stay on the catalog side while the resulting envelopes are canonical provider data.

The input is treated as immutable. Every output collection is freshly allocated and ordered according to the provider plan contract.

func ValidationProfileDigestV1 

func ValidationProfileDigestV1(profile ValidationProfileRecordV1) (canonical.Digest, error)

ValidationProfileDigestV1 validates a complete portable-tool validation profile and returns its canonical record identity.

Types

type ActiveFilesystemConstraintV1 

type ActiveFilesystemConstraintV1 struct {
	Path   string           `json:"path"`
	Digest canonical.Digest `json:"digest"`
}

type ActiveNativePackageConstraintV1 

type ActiveNativePackageConstraintV1 struct {
	Manager      string   `json:"manager"`
	Requirements []string `json:"requirements"`
	Repositories []string `json:"repositories"`
}

type ActiveProviderConstraintSourceV1 

type ActiveProviderConstraintSourceV1 struct {
	Scope          string                            `json:"scope"`
	Source         ConstraintSourceV1                `json:"source"`
	NativePackages []ActiveNativePackageConstraintV1 `json:"native_packages"`
	PythonBindings []ActivePythonBindingConstraintV1 `json:"python_bindings"`
	InstallRoots   []string                          `json:"install_roots"`
	OwnedPaths     []ActiveFilesystemConstraintV1    `json:"owned_paths"`
	Artifacts      []ActiveFilesystemConstraintV1    `json:"artifacts"`
	Environment    []RecordEnvironmentVariableV1     `json:"environment"`
	Exports        []ToolExportV1                    `json:"exports"`
	Capabilities   []ToolExportV1                    `json:"capabilities"`
}

ActiveProviderConstraintSourceV1 groups the constraints introduced by one stable source. Scope selects an existing ProviderDomainSetV1; callers cannot invent domain identities independently of the active provider graph.

type ActiveProviderConstraintsV1 

type ActiveProviderConstraintsV1 struct {
	Schema  string                             `json:"schema"`
	Sources []ActiveProviderConstraintSourceV1 `json:"sources"`
}

ActiveProviderConstraintsV1 is an explicit snapshot of constraints already present in the provider graph. Sources must be supplied as a canonical array, including an empty array when the active graph contributes no constraints.

type ActivePythonBindingConstraintV1 

type ActivePythonBindingConstraintV1 struct {
	Name                   string                             `json:"name"`
	Requirements           []string                           `json:"requirements"`
	SupportedPython        []string                           `json:"supported_python"`
	InterpreterConstraints []string                           `json:"interpreter_constraints,omitempty"`
	Overrides              []ActivePythonOverrideConstraintV1 `json:"overrides,omitempty"`
}

type ActivePythonOverrideConstraintV1 

type ActivePythonOverrideConstraintV1 struct {
	Distribution string `json:"distribution"`
	Kind         string `json:"kind"`
	Version      string `json:"version,omitempty"`
}

ActivePythonOverrideConstraintV1 carries ordinary Python package override intent into joint resolution. Version overrides are ordinary exact package constraints; local overrides remain explicit so a selected portable wheel can be rejected before acquisition rather than by a later projection pass.

type ArtifactSourceMappingV1 

type ArtifactSourceMappingV1 = portabletool.ArtifactSourceMappingV1

type ArtifactSourceRecordV1 

type ArtifactSourceRecordV1 = portabletool.ArtifactSourceRecordV1

type BindingArtifactRecordV1 

type BindingArtifactRecordV1 = portabletool.BindingArtifactRecordV1

type BindingContractV1 

type BindingContractV1 = portabletool.BindingContractV1

type BindingSetSchemaV1 

type BindingSetSchemaV1 = portabletool.BindingSetSchemaV1

type BundledComponentV1 

type BundledComponentV1 = portabletool.BundledComponentV1

type CanonicalBindingDemandV1 

type CanonicalBindingDemandV1 = toolrequest.CanonicalBindingDemandV1

CanonicalBindingDemandV1 and CanonicalRequirementGroupV1 remain exported from toolcatalog for solver callers while their catalog-independent parser representation lives in internal/toolrequest.

type CanonicalCatalogRecordV1 

type CanonicalCatalogRecordV1 struct {
	Path           string
	ID             string
	Digest         canonical.Digest
	CanonicalBytes []byte
}

CanonicalCatalogRecordV1 is one validated record ready for embedding. CanonicalBytes contains the exact bytes over which Digest was computed.

func ComposePortableToolCatalogV1 

func ComposePortableToolCatalogV1(definitions []PortableToolDefinitionRecordV1) ([]CanonicalCatalogRecordV1, error)

ComposePortableToolCatalogV1 resolves authoring references, validates the closed graph, and emits canonical JSON records in path order. It clones all input records and never performs acquisition, execution, inheritance, or overlay processing.

type CanonicalRequirementGroupV1 

type CanonicalRequirementGroupV1 = toolrequest.CanonicalRequirementGroupV1

type CatalogV1 

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

CatalogV1 is an immutable set of portable tool records indexed by exact identity, with the tool records reachable by qualified tool name.

func (*CatalogV1) DeriveIntegrationCasesV1 

func (catalog *CatalogV1) DeriveIntegrationCasesV1() ([]IntegrationCaseV1, error)

DeriveIntegrationCasesV1 preflights the complete catalog before returning any runnable cases. The target leaves, rather than release-wide context or option schemas, own the case set.

func (*CatalogV1) Names 

func (catalog *CatalogV1) Names() []string

Names lists the qualified tool names this catalog defines, in canonical order.

func (*CatalogV1) ResolveSelectedClosuresV1 

func (catalog *CatalogV1) ResolveSelectedClosuresV1(sets []ReleaseCandidateSetV1,
	domains []ProviderDomainSetV1, operation ResolutionOperationInputsV1) (JointResolutionV1, error)

ResolveSelectedClosuresV1 jointly solves PTD-09 candidate sets. Candidate enumeration and canonical group construction deliberately remain outside this method.

func (*CatalogV1) SelectReleaseCandidatesV1 

func (catalog *CatalogV1) SelectReleaseCandidatesV1(group CanonicalRequirementGroupV1,
	observed TargetIdentityV1, client ClientCapabilitiesV1, activeBindings []string) ([]ReleaseCandidateV1, error)

SelectReleaseCandidatesV1 normalizes the request, enumerates the releases it authorizes, and reduces them against the running client and observed target. Candidates are returned newest-first, so an older release that can satisfy the request survives when the newest cannot.

type ClientCapabilitiesV1 

type ClientCapabilitiesV1 struct {
	ReployVersion      string
	ResolverPrimitives []string
}

ClientCapabilitiesV1 describes the running client a candidate must satisfy.

func EmbeddedClientCapabilitiesV1 

func EmbeddedClientCapabilitiesV1(reployVersion string) (ClientCapabilitiesV1, error)

EmbeddedClientCapabilitiesV1 describes the running Reploy client for embedded-catalog candidate selection.

type ConstraintSourceV1 

type ConstraintSourceV1 struct {
	Kind string `json:"kind"`
	ID   string `json:"id"`
}

ConstraintSourceV1 identifies the canonical input that introduced an active provider constraint. Kind describes the source family, such as blueprint or lock-state, while ID is a stable identifier within that family.

type EmbeddedPortableToolArtifactSourceV1 

type EmbeddedPortableToolArtifactSourceV1 struct {
	Scope      string
	Tool       string
	Artifact   providers.PortableToolRecordReferenceV1
	Descriptor providerstore.ArtifactDescriptor
	Source     providers.PortableToolSelectedRecordV1
	Mirrors    []string
}

EmbeddedPortableToolArtifactSourceV1 joins one selected artifact with the exact catalog source record that authorizes its acquisition.

type EmbeddedPortableToolLockRecordSetV1 

type EmbeddedPortableToolLockRecordSetV1 struct {
	Releases  []providers.PortableToolReleaseManifestInputV1
	Artifacts []EmbeddedPortableToolArtifactSourceV1
}

EmbeddedPortableToolLockRecordSetV1 carries the manifest and source records a build lock must retain for selected closures.

func EmbeddedPortableToolLockRecordsV1 

func EmbeddedPortableToolLockRecordsV1(closures []SelectedClosureV1) (EmbeddedPortableToolLockRecordSetV1, error)

EmbeddedPortableToolLockRecordsV1 resolves, from the immutable embedded catalog, the release manifest that authorized each selected closure and the artifact-source record mapped to every selected payload or binding artifact. It reads catalog records only; it performs no acquisition.

type ImmutableOperationSnapshotV1 

type ImmutableOperationSnapshotV1 struct {
	CanonicalJSON string           `json:"canonical_json"`
	Digest        canonical.Digest `json:"digest"`
}

ImmutableOperationSnapshotV1 is the complete canonical operation payload. A string owns its bytes, so acquisition can carry it unchanged without aliasing maps supplied by the caller.

type IntegrationCaseV1 

type IntegrationCaseV1 struct {
	ID                canonical.Digest
	ManifestReference RecordReferenceV1
	Manifest          ReleaseManifestV1
	TargetReference   RecordReferenceV1
	Target            TargetRecordV1
	Support           TargetSupportCaseV1
	Fixture           IntegrationFixtureRecordV1
	Profiles          []ValidationProfileRecordV1
}

IntegrationCaseV1 is one advertised target support case paired with its exact fixture and selected profiles. Derivation does not run or validate an image and does not create external support evidence.

func EmbeddedIntegrationCasesV1 

func EmbeddedIntegrationCasesV1() ([]IntegrationCaseV1, error)

EmbeddedIntegrationCasesV1 exposes the same preflight over the generated first-party catalog for integration harnesses.

type IntegrationFixtureRecordV1 

type IntegrationFixtureRecordV1 = portabletool.IntegrationFixtureRecordV1

type JointResolutionV1 

type JointResolutionV1 struct {
	Closures      []SelectedClosureV1          `json:"closures"`
	Snapshot      ImmutableOperationSnapshotV1 `json:"snapshot"`
	VisitedStates string                       `json:"visited_states"`
}

func ResolveEmbeddedPortableToolPlanByScopeV1 

func ResolveEmbeddedPortableToolPlanByScopeV1(
	groups []CanonicalRequirementGroupV1,
	target TargetIdentityV1,
	client ClientCapabilitiesV1,
	activeBindingsByScope map[string][]string,
	domains []ProviderDomainSetV1,
	operation ResolutionOperationInputsV1,
) (providers.PortableToolPlanV1, JointResolutionV1, error)

ResolveEmbeddedPortableToolPlanByScopeV1 is the application-aware variant of ResolveEmbeddedPortableToolPlanV1. Binding inference is evaluated with the active ordinary providers for the candidate's own resolution scope; providers from another application cannot influence an omitted binding.

func ResolveEmbeddedPortableToolPlanV1 

func ResolveEmbeddedPortableToolPlanV1(
	groups []CanonicalRequirementGroupV1,
	target TargetIdentityV1,
	client ClientCapabilitiesV1,
	activeBindings []string,
	domains []ProviderDomainSetV1,
	operation ResolutionOperationInputsV1,
) (providers.PortableToolPlanV1, JointResolutionV1, error)

ResolveEmbeddedPortableToolPlanV1 selects and jointly resolves canonical portable-tool requirement groups against Reploy's immutable embedded catalog, then compiles the selected closures into a provider-neutral plan. It returns the compiled plan and the joint result so callers can carry the selected closures and immutable operation snapshot into later stages.

The Catalog and Platform fields of operation are deliberately ignored. The helper replaces them with identities derived from the embedded catalog and the exact validated target used for selection, preventing callers from fabricating either input. This function performs no acquisition or materialization.

type NativePackageSetV1 

type NativePackageSetV1 = portabletool.NativePackageSetV1

type PayloadRecordV1 

type PayloadRecordV1 = portabletool.PayloadRecordV1

type PortableToolAuthoringEntryV1 

type PortableToolAuthoringEntryV1 struct {
	SourcePath string
	OutputPath string
}

PortableToolAuthoringEntryV1 maps one authoring source to its exact catalog-relative JSON output path. SourcePath is relative to the trusted authoring boundary.

type PortableToolAuthoringResultV1 

type PortableToolAuthoringResultV1 struct {
	Records []CanonicalCatalogRecordV1
	Sources []PortableToolAuthoringSourceV1
}

PortableToolAuthoringResultV1 contains canonical composer output and the sorted transitive source manifest that produced it.

func LoadPortableToolAuthoringV1 

func LoadPortableToolAuthoringV1(boundary string, entries []PortableToolAuthoringEntryV1) (PortableToolAuthoringResultV1, error)

LoadPortableToolAuthoringV1 resolves strict localized authoring sources beneath boundary and delegates canonical record production to the PTD-11 composer. It performs no runtime inheritance or overlay processing.

type PortableToolAuthoringSourceV1 

type PortableToolAuthoringSourceV1 struct {
	Path   string
	SHA256 canonical.Digest
}

PortableToolAuthoringSourceV1 records the exact bytes consumed for one reachable source. Path is normalized relative to the trusted boundary.

type PortableToolDefinitionRecordV1 

type PortableToolDefinitionRecordV1 struct {
	Path   string
	Record PortableToolRecordV1
}

PortableToolDefinitionRecordV1 places one typed authoring record at its intended catalog path. References must name an exact record ID. A missing digest is resolved by the composer when that ID is unambiguous; a supplied digest is always checked and is required when multiple revisions define the same ID.

type PortableToolRecordV1 

type PortableToolRecordV1 = portabletool.RecordV1

PortableToolRecordV1 is retained as a compatibility alias for the shared canonical portable-tool record contract.

type ProviderDomainSetV1 

type ProviderDomainSetV1 struct {
	Scope          string `json:"scope"`
	PackageManager string `json:"package_manager"`
	// Binding names the provider-owned Python binding/package authority. It is
	// distinct from PackageManager because the APT transaction is shared while
	// application Python roots remain isolated. Older callers that omit Binding
	// retain the historical package-manager behavior.
	Binding      string `json:"binding,omitempty"`
	Filesystem   string `json:"filesystem"`
	Environment  string `json:"environment"`
	Exports      string `json:"exports"`
	Capabilities string `json:"capabilities"`
}

ProviderDomainSetV1 names the provider and destination authority domains visible from one canonical resolution scope. Equal names mean that two scopes genuinely share that authority; unequal names keep their constraints isolated.

type RecordEnvironmentVariableV1 

type RecordEnvironmentVariableV1 = portabletool.RecordEnvironmentVariableV1

type RecordProbeV1 

type RecordProbeV1 = portabletool.RecordProbeV1

type RecordReferenceV1 

type RecordReferenceV1 = portabletool.RecordReferenceV1

type RecordRuntimeV1 

type RecordRuntimeV1 = portabletool.RecordRuntimeV1

type ReleaseCandidateSetV1 

type ReleaseCandidateSetV1 struct {
	Group      CanonicalRequirementGroupV1
	Candidates []ReleaseCandidateV1
}

ReleaseCandidateSetV1 is the PTD-09 output for one canonical requirement group. PTD-10 orders these sets independently of request input order.

type ReleaseCandidateV1 

type ReleaseCandidateV1 struct {
	Scope         string
	Manifest      ReleaseManifestV1
	Contract      ReleaseContractV1
	Target        TargetRecordV1
	Fixture       IntegrationFixtureRecordV1
	Profiles      []ValidationProfileRecordV1
	Bindings      []string
	Selections    map[string][]string
	Contributions []RecordReferenceV1
	Exports       []ToolExportV1
}

ReleaseCandidateV1 is one release that could satisfy a request on a target, with the contributions its own references select.

type ReleaseContractV1 

type ReleaseContractV1 = portabletool.ReleaseContractV1

type ReleaseManifestV1 

type ReleaseManifestV1 = portabletool.ReleaseManifestV1

type ReleaseProvenanceV1 

type ReleaseProvenanceV1 struct {
	Tool           string           `json:"tool"`
	Version        string           `json:"version"`
	Revision       string           `json:"revision"`
	ManifestDigest canonical.Digest `json:"manifest_digest"`
}

type ResolutionOperationInputsV1 

type ResolutionOperationInputsV1 struct {
	Blueprint       canonical.Envelope          `json:"blueprint"`
	Reploy          canonical.Envelope          `json:"reploy"`
	Platform        canonical.Envelope          `json:"platform"`
	Catalog         canonical.Envelope          `json:"catalog"`
	ActiveProviders ActiveProviderConstraintsV1 `json:"active_providers"`
}

ResolutionOperationInputsV1 carries the complete canonical inputs that must remain fixed after joint solving. The selected candidate constraints are added by the solver before the immutable snapshot is sealed.

type SelectedBindingArtifactRecordV1 

type SelectedBindingArtifactRecordV1 struct {
	Reference RecordReferenceV1       `json:"reference"`
	Record    BindingArtifactRecordV1 `json:"record"`
}

type SelectedBindingContractRecordV1 

type SelectedBindingContractRecordV1 struct {
	Reference RecordReferenceV1 `json:"reference"`
	Record    BindingContractV1 `json:"record"`
}

type SelectedClosureRecordsV1 

type SelectedClosureRecordsV1 struct {
	BindingContracts []SelectedBindingContractRecordV1 `json:"binding_contracts"`
	BindingArtifacts []SelectedBindingArtifactRecordV1 `json:"binding_artifacts"`
	Payloads         []SelectedPayloadRecordV1         `json:"payloads"`
	PackageSets      []SelectedPackageSetRecordV1      `json:"package_sets"`
}

type SelectedClosureV1 

type SelectedClosureV1 struct {
	Scope      string                       `json:"scope"`
	Provenance ReleaseProvenanceV1          `json:"provenance"`
	Contract   SelectedContractProjectionV1 `json:"contract"`
	Target     SelectedTargetProjectionV1   `json:"target"`
	Records    SelectedClosureRecordsV1     `json:"records"`
	Fixture    IntegrationFixtureRecordV1   `json:"fixture"`
	Profiles   []ValidationProfileRecordV1  `json:"profiles"`
	Identity   canonical.Digest             `json:"identity"`
}

SelectedClosureV1 owns every selected record and every validation record it returns. Validation records authorize support but remain outside Identity.

func EmbeddedSelectedClosureForIntegrationCaseV1 

func EmbeddedSelectedClosureForIntegrationCaseV1(caseV1 IntegrationCaseV1, scope string) (SelectedClosureV1, error)

EmbeddedSelectedClosureForIntegrationCaseV1 reconstructs the complete selected closure for one authenticated catalog case and caller-owned scope. Unlike a caller-supplied closure or lock digest, its runtime, exports, target contributions, and selected records come from embedded definitions.

type SelectedContractProjectionV1 

type SelectedContractProjectionV1 struct {
	Context    string              `json:"context"`
	Bindings   []string            `json:"bindings"`
	Selections map[string][]string `json:"selections"`
	Runtime    *RecordRuntimeV1    `json:"runtime"`
	Exports    []ToolExportV1      `json:"exports"`
}

SelectedContractProjectionV1 contains only behavior selected from a release contract. Bindings is nil when no binding was selected, as required by the selected-closure identity schema.

type SelectedPackageSetRecordV1 

type SelectedPackageSetRecordV1 struct {
	Reference RecordReferenceV1  `json:"reference"`
	Record    NativePackageSetV1 `json:"record"`
}

type SelectedPayloadRecordV1 

type SelectedPayloadRecordV1 struct {
	Reference RecordReferenceV1 `json:"reference"`
	Record    PayloadRecordV1   `json:"record"`
}

type SelectedTargetBindingV1 

type SelectedTargetBindingV1 struct {
	Name        string              `json:"name"`
	Contract    RecordReferenceV1   `json:"contract"`
	Artifacts   []RecordReferenceV1 `json:"artifacts"`
	PackageSets []RecordReferenceV1 `json:"package_sets"`
	Exports     []ToolExportV1      `json:"exports"`
}

type SelectedTargetProjectionV1 

type SelectedTargetProjectionV1 struct {
	Identity    TargetIdentityV1            `json:"identity"`
	PackageSets []RecordReferenceV1         `json:"package_sets"`
	Bindings    []SelectedTargetBindingV1   `json:"bindings"`
	Payloads    []RecordReferenceV1         `json:"payloads"`
	Selections  []SelectedTargetSelectionV1 `json:"selections"`
	Exports     []ToolExportV1              `json:"exports"`
}

type SelectedTargetSelectionV1 

type SelectedTargetSelectionV1 struct {
	Dimension   string              `json:"dimension"`
	Value       string              `json:"value"`
	Payloads    []RecordReferenceV1 `json:"payloads"`
	PackageSets []RecordReferenceV1 `json:"package_sets"`
	Exports     []ToolExportV1      `json:"exports"`
}

type SelectionCombinationV1 

type SelectionCombinationV1 = portabletool.SelectionCombinationV1

type SelectionDimensionV1 

type SelectionDimensionV1 = portabletool.SelectionDimensionV1

type SelectionSchemaV1 

type SelectionSchemaV1 = portabletool.SelectionSchemaV1

type TargetBindingV1 

type TargetBindingV1 = portabletool.TargetBindingV1

type TargetIdentityV1 

type TargetIdentityV1 = portabletool.TargetIdentityV1

type TargetRecordV1 

type TargetRecordV1 = portabletool.TargetRecordV1

type TargetSelectionV1 

type TargetSelectionV1 = portabletool.TargetSelectionV1

type TargetSupportCaseV1 

type TargetSupportCaseV1 = portabletool.TargetSupportCaseV1

type ToolExportV1 

type ToolExportV1 = portabletool.ToolExportV1

type ToolRecordV1 

type ToolRecordV1 = portabletool.ToolRecordV1

type ValidationEvidenceV1 

type ValidationEvidenceV1 = portabletool.ValidationEvidenceV1

func DecodePortableToolValidationEvidenceV1 

func DecodePortableToolValidationEvidenceV1(payload []byte) (ValidationEvidenceV1, error)

DecodePortableToolValidationEvidenceV1 decodes and validates an external evidence record. A valid record alone does not establish current support.

type ValidationProfileRecordV1 

type ValidationProfileRecordV1 = portabletool.ValidationProfileRecordV1

func DecodePortableToolValidationProfileV1 

func DecodePortableToolValidationProfileV1(
	reference providers.PortableToolRecordReferenceV1,
	data providers.CanonicalProviderData,
) (ValidationProfileRecordV1, error)

DecodePortableToolValidationProfileV1 converts one canonical provider envelope back into the exact validation-profile record it was compiled from. It is the sole plan-to-executor conversion boundary: a scheduler decodes the profile carried by the plan rather than re-reading catalog state, so locked replay cannot pick up a moving definition.

The reference is authoritative. Decoding is strict, the decoded record is revalidated, and its recomputed identity must equal the reference digest, so a substituted or mutated envelope fails before any probe runs.

Source Files

View all Source files

Directories

Path Synopsis
cmd
cataloggen command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.