From 6900cad104d2e0b5c95cd8d006c89ffd70832b1f Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Fri, 20 Nov 2026 04:33:02 +0000 Subject: [PATCH] Derive artifact catalogs from the selected party without changing configuration --- docs/roadmap/implementation.md | 9 + internal/config/artifact_catalog.go | 28 +-- internal/config/artifact_dependencies.go | 11 +- internal/config/artifact_dependencies_test.go | 10 +- internal/config/artifact_families.go | 169 ++++++++---------- internal/config/artifact_families_test.go | 56 +++--- internal/config/catalog_derivation_test.go | 125 +++++++++++++ internal/config/config.go | 35 ++-- internal/config/effective_pipeline.go | 33 +--- internal/config/load.go | 64 ++++--- internal/config/load_validate_test.go | 18 +- internal/config/notarius_test.go | 5 +- internal/config/party.go | 24 ++- internal/config/party_imports_test.go | 2 +- internal/config/party_resolution.go | 21 +++ internal/config/pipeline_configkit.go | 19 +- internal/config/pipeline_configkit_test.go | 20 +-- internal/config/scriptorium_test.go | 32 ++-- internal/config/storage_publish_test.go | 15 +- internal/config/validate.go | 8 +- internal/config/validate_core.go | 4 +- internal/config/validate_publish.go | 27 ++- internal/config/validate_scriptorium.go | 26 ++- 23 files changed, 446 insertions(+), 315 deletions(-) create mode 100644 internal/config/catalog_derivation_test.go diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index 68d6006..081a90b 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -197,6 +197,15 @@ no later operation changes the captured session or campaign result. ## Stage 4: Derive party products and concrete artifact catalogs +**Completed.** Exposed the retained typed party result and exact explicit-roster +selection. Concrete artifacts, dependency closure, family/member provenance, +players, and publication rules are derived separately; completed pipeline and +campaign values remain unchanged. Removed expansion state from PipelineConfig. +The full configuration package and maintained examples pass with Go 1.27.4, +including the dependency tests deferred from Stage 2 and independent-roster +regressions. Whole-application compilation awaits the family-origin consumers' +catalog wiring in Stage 5; no compatibility dispatcher or snapshot was added. + Read: `internal/config/party*.go`, `artifact_families.go`, `artifact_catalog.go`, the family declarations in `config.go`, and the roadmap's ownership boundary. diff --git a/internal/config/artifact_catalog.go b/internal/config/artifact_catalog.go index 59aa1a8..064e258 100644 --- a/internal/config/artifact_catalog.go +++ b/internal/config/artifact_catalog.go @@ -1,7 +1,6 @@ package config import ( - "fmt" "sort" "strings" @@ -27,15 +26,20 @@ type EffectiveArtifactRecord struct { // EffectiveArtifactCatalog returns the deterministic concrete artifact catalog // consumed by runtime planning. func EffectiveArtifactCatalog(cfg *PipelineConfig, party ResolvedParty) ([]EffectiveArtifactRecord, error) { - if cfg == nil { - return nil, fmt.Errorf("pipeline config is required") + catalog, err := DeriveArtifactCatalog(cfg, party) + if err != nil { + return nil, err } - if cfg.Scriptorium == nil || len(cfg.Scriptorium.Artifacts) == 0 { - return []EffectiveArtifactRecord{}, nil + return catalog.Records, nil +} + +func concreteArtifactRecords(cfg *PipelineConfig, catalog *ArtifactCatalog, party ResolvedParty) []EffectiveArtifactRecord { + if len(catalog.Artifacts) == 0 { + return []EffectiveArtifactRecord{} } - keys := make([]string, 0, len(cfg.Scriptorium.Artifacts)) - for key := range cfg.Scriptorium.Artifacts { + keys := make([]string, 0, len(catalog.Artifacts)) + for key := range catalog.Artifacts { keys = append(keys, key) } sort.Strings(keys) @@ -43,7 +47,7 @@ func EffectiveArtifactCatalog(cfg *PipelineConfig, party ResolvedParty) ([]Effec pathsByID := pipelineSourcePaths(cfg) partySources := partyCharacterSourceLookup(party) for _, key := range keys { - artifact := cfg.Scriptorium.Artifacts[key] + artifact := catalog.Artifacts[key] record := EffectiveArtifactRecord{ Key: key, SourceID: artifactpolicy.ConfiguredSourceID(key), @@ -51,11 +55,11 @@ func EffectiveArtifactCatalog(cfg *PipelineConfig, party ResolvedParty) ([]Effec OutputPath: artifact.OutputPath, Dependencies: append([]string(nil), artifact.DependsOn...), } - if member, ok := cfg.familyCatalog.Members[key]; ok { - record.DefinitionSources = append([]string(nil), cfg.familyCatalog.Families[member.Family].Sources...) + if member, ok := catalog.Families.Members[key]; ok { + record.DefinitionSources = append([]string(nil), catalog.Families.Families[member.Family].Sources...) record.FamilyKey = member.Family record.CharacterID = member.CharacterID - record.FamilySources = append([]string(nil), cfg.familyCatalog.Families[member.Family].Sources...) + record.FamilySources = append([]string(nil), catalog.Families.Families[member.Family].Sources...) record.PartySource = strings.Join(partySources(member.CharacterID), ",") } else { record.DefinitionSources = declarationDefinitionSourcesWithIndex(cfg, configkit.Keys("scriptorium", "artifacts", key), pathsByID) @@ -63,7 +67,7 @@ func EffectiveArtifactCatalog(cfg *PipelineConfig, party ResolvedParty) ([]Effec record.Dependencies = nonEmptySortedStrings(record.Dependencies) records = append(records, record) } - return records, nil + return records } // partyCharacterSourceLookup owns a single inspection's detached native evidence. diff --git a/internal/config/artifact_dependencies.go b/internal/config/artifact_dependencies.go index 260e195..7a63ad2 100644 --- a/internal/config/artifact_dependencies.go +++ b/internal/config/artifact_dependencies.go @@ -14,16 +14,13 @@ type artifactDependencyOrigin struct { family string } -func finalizeArtifactDependencies(cfg *PipelineConfig) { - if cfg == nil || cfg.Scriptorium == nil { - return - } - for artifactName, artifact := range cfg.Scriptorium.Artifacts { +func resolveArtifactDependencies(artifacts map[string]ScriptoriumArtifactConfig, families ArtifactFamilyCatalog) { + for artifactName, artifact := range artifacts { priorOrigins := artifact.dependencyOrigins origins := make(map[string][]artifactDependencyOrigin) dependencies := make(map[string]struct{}) family := "" - if member, ok := cfg.familyCatalog.Members[artifactName]; ok { + if member, ok := families.Members[artifactName]; ok { family = member.Family } @@ -65,7 +62,7 @@ func finalizeArtifactDependencies(cfg *PipelineConfig) { artifact.DependsOn = sortedDependencyKeys(dependencies) artifact.dependencyOrigins = origins - cfg.Scriptorium.Artifacts[artifactName] = artifact + artifacts[artifactName] = artifact } } diff --git a/internal/config/artifact_dependencies_test.go b/internal/config/artifact_dependencies_test.go index cb8591a..568a986 100644 --- a/internal/config/artifact_dependencies_test.go +++ b/internal/config/artifact_dependencies_test.go @@ -6,7 +6,7 @@ import ( "testing" ) -func TestFinalizeArtifactDependenciesUnionsNormalizesAndIsIdempotent(t *testing.T) { +func TestArtifactDependencyResolutionUnionsNormalizesAndIsIdempotent(t *testing.T) { cfg := dependencyTestPipeline([]string{" beta ", "alpha", "beta"}) artifact := cfg.Scriptorium.Artifacts["result"] artifact.Inputs["gamma"] = ScriptoriumInputConfig{Source: "narratio.artifact.gamma"} @@ -14,7 +14,7 @@ func TestFinalizeArtifactDependenciesUnionsNormalizesAndIsIdempotent(t *testing. cfg.Scriptorium.Artifacts["result"] = artifact cfg.Scriptorium.Artifacts["gamma"] = ScriptoriumArtifactConfig{} - finalizeArtifactDependencies(cfg) + resolveArtifactDependencies(cfg.Scriptorium.Artifacts, ArtifactFamilyCatalog{}) want := []string{"alpha", "beta", "gamma"} got := cfg.Scriptorium.Artifacts["result"] if !reflect.DeepEqual(got.DependsOn, want) { @@ -25,7 +25,7 @@ func TestFinalizeArtifactDependenciesUnionsNormalizesAndIsIdempotent(t *testing. } firstOrigins := cloneDependencyOrigins(got.dependencyOrigins) - finalizeArtifactDependencies(cfg) + resolveArtifactDependencies(cfg.Scriptorium.Artifacts, ArtifactFamilyCatalog{}) got = cfg.Scriptorium.Artifacts["result"] if !reflect.DeepEqual(got.DependsOn, want) { t.Fatalf("dependencies after second finalization = %#v, want %#v", got.DependsOn, want) @@ -66,7 +66,7 @@ func TestInferredArtifactDependencyDiagnosticsPointToInputs(t *testing.T) { } { t.Run(test.name, func(t *testing.T) { cfg := &PipelineConfig{Scriptorium: &ScriptoriumConfig{Artifacts: test.artifacts}} - finalizeArtifactDependencies(cfg) + resolveArtifactDependencies(cfg.Scriptorium.Artifacts, ArtifactFamilyCatalog{}) err := ValidateScriptoriumArtifactDependencies(cfg.Scriptorium.Artifacts) if err == nil { t.Fatal("expected dependency validation error") @@ -84,7 +84,7 @@ func TestExplicitAndInferredDependencyGraphsHaveEqualDigests(t *testing.T) { explicit := dependencyTestPipeline([]string{"alpha"}) inferred := dependencyTestPipeline(nil) for _, cfg := range []*PipelineConfig{explicit, inferred} { - finalizeArtifactDependencies(cfg) + resolveArtifactDependencies(cfg.Scriptorium.Artifacts, ArtifactFamilyCatalog{}) cfg.resolution = &pipelineResolutionMetadata{} if err := recomputePipelineEffectiveDigest(cfg); err != nil { t.Fatal(err) diff --git a/internal/config/artifact_families.go b/internal/config/artifact_families.go index 110984e..bd20a5a 100644 --- a/internal/config/artifact_families.go +++ b/internal/config/artifact_families.go @@ -22,46 +22,41 @@ var memberVariableSelectors = map[string]func(PartyCharacter) string{ "character.alias_summary": func(character PartyCharacter) string { return character.AliasSummary() }, } -func retainArtifactFamilyDeclarations(cfg *PipelineConfig) { - if cfg == nil || cfg.Scriptorium == nil || cfg.resolution == nil { - return +// DeriveArtifactCatalog interprets the completed pipeline and selected roster +// without changing either native configuration result. +func DeriveArtifactCatalog(cfg *PipelineConfig, party ResolvedParty) (*ArtifactCatalog, error) { + if cfg == nil { + return nil, fmt.Errorf("pipeline config is required") } - cfg.resolution.artifactFamilies = cloneArtifactFamilyDefinitions(cfg.Scriptorium.ArtifactFamilies) -} - -func expandPipelineArtifactFamilies(cfg *PipelineConfig, party ResolvedParty) error { - if cfg == nil || cfg.Scriptorium == nil || cfg.resolution == nil || cfg.resolution.artifactFamiliesExpanded { - return nil + result := &ArtifactCatalog{Artifacts: map[string]ScriptoriumArtifactConfig{}} + if cfg.Scriptorium == nil { + return finishArtifactCatalog(cfg, result, party) } - families := cfg.resolution.artifactFamilies - if len(families) == 0 { - families = cloneArtifactFamilyDefinitions(cfg.Scriptorium.ArtifactFamilies) + families := cfg.Scriptorium.ArtifactFamilies + if len(families) > 0 && party.Canonical == nil { + return nil, fmt.Errorf("pipeline.scriptorium.artifact_families requires a canonical party") } - if len(families) == 0 { - return nil - } - if party.Canonical == nil { - return fmt.Errorf("pipeline.scriptorium.artifact_families requires a canonical campaign party") - } - expanded := cloneArtifactDefinitions(cfg.Scriptorium.Artifacts) if err := rejectConcreteMemberArtifactSources(expanded); err != nil { - return err + return nil, err } familyKeys := sortedFamilyKeys(families) for _, familyKey := range familyKeys { if !artifactpolicy.IsConfiguredKey(familyKey) { - return fmt.Errorf("pipeline.scriptorium.artifact_families keys must match ^[a-z][a-z0-9_]*$") + return nil, fmt.Errorf("pipeline.scriptorium.artifact_families keys must match ^[a-z][a-z0-9_]*$") } if _, exists := expanded[familyKey]; exists { - return fmt.Errorf("pipeline.scriptorium.artifact_families.%s collides with configured artifact key %q", familyKey, familyKey) + return nil, fmt.Errorf("pipeline.scriptorium.artifact_families.%s collides with configured artifact key %q", familyKey, familyKey) } } if err := validateFamilyMemberDependencies(families, familyKeys); err != nil { - return err + return nil, err } - characters := append([]PartyCharacter(nil), party.Canonical.Characters...) + characters := []PartyCharacter(nil) + if party.Canonical != nil { + characters = append(characters, party.Canonical.Characters...) + } sort.Slice(characters, func(left, right int) bool { return characters[left].ID < characters[right].ID }) catalog := ArtifactFamilyCatalog{Families: make(map[string]ArtifactFamilyOrigin, len(familyKeys)), Members: map[string]ArtifactFamilyMemberOrigin{}} outputOwners := make(map[string]string, len(expanded)) @@ -74,10 +69,10 @@ func expandPipelineArtifactFamilies(cfg *PipelineConfig, party ResolvedParty) er family := families[familyKey] prefix := "pipeline.scriptorium.artifact_families." + familyKey if strings.TrimSpace(family.ForEach) != partyCharactersFamilySource { - return fmt.Errorf("%s.for_each must be %q", prefix, partyCharactersFamilySource) + return nil, fmt.Errorf("%s.for_each must be %q", prefix, partyCharactersFamilySource) } if err := validateFamilyOutputPattern(prefix+".output_path_pattern", family.OutputPathPattern); err != nil { - return err + return nil, err } familyOrigin := ArtifactFamilyOrigin{ Members: make([]string, 0, len(characters)), @@ -88,26 +83,26 @@ func expandPipelineArtifactFamilies(cfg *PipelineConfig, party ResolvedParty) er for _, character := range characters { key := familyKey + "_" + character.ID if !artifactpolicy.IsConfiguredKey(key) { - return fmt.Errorf("%s generates invalid artifact key %q", prefix, key) + return nil, fmt.Errorf("%s generates invalid artifact key %q", prefix, key) } if _, exists := expanded[key]; exists { - return fmt.Errorf("%s generates artifact key %q that collides with another artifact", prefix, key) + return nil, fmt.Errorf("%s generates artifact key %q that collides with another artifact", prefix, key) } outputPath := strings.ReplaceAll(family.OutputPathPattern, characterIDToken, character.ID) if prior, exists := outputOwners[outputPath]; exists { - return fmt.Errorf("%s.output_path_pattern generates output path %q already used by artifact %q", prefix, outputPath, prior) + return nil, fmt.Errorf("%s.output_path_pattern generates output path %q already used by artifact %q", prefix, outputPath, prior) } vars, err := resolveFamilyVars(prefix, family, character) if err != nil { - return err + return nil, err } dependencies, err := expandedFamilyDependencies(prefix, family, character.ID) if err != nil { - return err + return nil, err } inputs, err := expandFamilyInputs(prefix, family, character.ID) if err != nil { - return err + return nil, err } expanded[key] = ScriptoriumArtifactConfig{ Enabled: family.Enabled, DependsOn: dependencies, RenderDebug: family.RenderDebug, @@ -120,52 +115,43 @@ func expandPipelineArtifactFamilies(cfg *PipelineConfig, party ResolvedParty) er } catalog.Families[familyKey] = familyOrigin } - cfg.Scriptorium.Artifacts = expanded - if err := expandFamilyPublishRules(cfg, catalog); err != nil { - return err - } - applyMissingPublishDestinations(cfg.Publish, cfg.Scriptorium, cfg.Notarius) - cfg.Scriptorium.ArtifactFamilies = nil - cfg.familyCatalog = catalog - cfg.resolution.artifactFamiliesExpanded = true - finalizeArtifactDependencies(cfg) - for key, member := range cfg.familyCatalog.Members { - member.Dependencies = append([]string(nil), cfg.Scriptorium.Artifacts[key].DependsOn...) - cfg.familyCatalog.Members[key] = member - } - if err := rejectConcreteMemberArtifactSources(expanded); err != nil { - return err - } - if err := validateScriptorium(cfg.Scriptorium, cfg.Notarius); err != nil { - return err - } - if err := validatePublish(cfg.Publish, cfg.Scriptorium, cfg.Notarius); err != nil { - return err - } - if err := recomputePipelineEffectiveDigest(cfg); err != nil { - return fmt.Errorf("refresh expanded pipeline digest: %w", err) - } - return nil + result.Artifacts = expanded + result.Families = catalog + return finishArtifactCatalog(cfg, result, party) } -func expandFamilyPublishRules(cfg *PipelineConfig, catalog ArtifactFamilyCatalog) error { - if cfg == nil || cfg.Scriptorium == nil { - return nil +func finishArtifactCatalog(cfg *PipelineConfig, catalog *ArtifactCatalog, party ResolvedParty) (*ArtifactCatalog, error) { + resolveArtifactDependencies(catalog.Artifacts, catalog.Families) + for key, member := range catalog.Families.Members { + member.Dependencies = append([]string(nil), catalog.Artifacts[key].DependsOn...) + catalog.Families.Members[key] = member } + if err := validateConcreteArtifacts(catalog.Artifacts, cfg.Notarius); err != nil { + return nil, err + } + if err := deriveFamilyPublishRules(cfg, catalog); err != nil { + return nil, err + } + catalog.Records = concreteArtifactRecords(cfg, catalog, party) + return catalog, nil +} + +func deriveFamilyPublishRules(cfg *PipelineConfig, catalog *ArtifactCatalog) error { if cfg.Publish == nil { - for familyKey, family := range catalog.Families { + for familyKey, family := range catalog.Families.Families { if family.Publish != nil && family.Publish.Enabled { return fmt.Errorf("pipeline.scriptorium.artifact_families.%s.publish requires pipeline.publish", familyKey) } } return nil } + catalog.PublishOutputs = append([]PublishOutputRule(nil), cfg.Publish.Outputs...) generated := make([]PublishOutputRule, 0) explicitSources := make(map[string]struct{}, len(cfg.Publish.Outputs)) for _, rule := range cfg.Publish.Outputs { explicitSources[strings.TrimSpace(rule.Source)] = struct{}{} } - for familyKey, family := range catalog.Families { + for familyKey, family := range catalog.Families.Families { if family.Publish == nil || !family.Publish.Enabled { continue } @@ -179,8 +165,8 @@ func expandFamilyPublishRules(cfg *PipelineConfig, catalog ArtifactFamilyCatalog if _, conflict := explicitSources[artifactpolicy.ConfiguredSourceID(key)]; conflict { return fmt.Errorf("pipeline.scriptorium.artifact_families.%s.publish conflicts with explicit publish source %q", familyKey, artifactpolicy.ConfiguredSourceID(key)) } - origin := catalog.Members[key] - dest := cfg.Scriptorium.Artifacts[key].OutputPath + origin := catalog.Families.Members[key] + dest := catalog.Artifacts[key].OutputPath if pattern != "" { dest = strings.ReplaceAll(pattern, characterIDToken, origin.CharacterID) } @@ -188,17 +174,27 @@ func expandFamilyPublishRules(cfg *PipelineConfig, catalog ArtifactFamilyCatalog generated = append(generated, PublishOutputRule{Source: artifactpolicy.ConfiguredSourceID(key), Dest: dest, Required: &required}) } } - if len(generated) == 0 { - return nil - } - cfg.Publish.Outputs = append(cfg.Publish.Outputs, generated...) - sort.Slice(cfg.Publish.Outputs, func(i, j int) bool { - if cfg.Publish.Outputs[i].Dest == cfg.Publish.Outputs[j].Dest { - return cfg.Publish.Outputs[i].Source < cfg.Publish.Outputs[j].Source + catalog.PublishOutputs = append(catalog.PublishOutputs, generated...) + outputPaths := artifactOutputPathMap(catalog.Artifacts) + extractions := notariusOutputKeySet(cfg.Notarius) + for index, rule := range catalog.PublishOutputs { + if strings.TrimSpace(rule.Dest) != "" { + continue } - return cfg.Publish.Outputs[i].Dest < cfg.Publish.Outputs[j].Dest - }) - return nil + dest, err := artifactpolicy.ResolvePublishedDestinationWithExtractions(strings.TrimSpace(rule.Source), "", outputPaths, extractions) + if err == nil { + catalog.PublishOutputs[index].Dest = dest + } + } + if len(generated) > 0 { + sort.Slice(catalog.PublishOutputs, func(i, j int) bool { + if catalog.PublishOutputs[i].Dest == catalog.PublishOutputs[j].Dest { + return catalog.PublishOutputs[i].Source < catalog.PublishOutputs[j].Source + } + return catalog.PublishOutputs[i].Dest < catalog.PublishOutputs[j].Dest + }) + } + return validatePublishedOutputs(catalog.PublishOutputs, outputPaths, extractions) } func validateFamilyMemberDependencies(families map[string]ScriptoriumArtifactFamilyConfig, familyKeys []string) error { @@ -388,29 +384,6 @@ func cloneArtifactVars(in map[string]any) map[string]any { return out } -func cloneArtifactFamilyDefinitions(in map[string]ScriptoriumArtifactFamilyConfig) map[string]ScriptoriumArtifactFamilyConfig { - if len(in) == 0 { - return nil - } - out := make(map[string]ScriptoriumArtifactFamilyConfig, len(in)) - for key, family := range in { - family.DependsOn = append([]string(nil), family.DependsOn...) - family.MemberDependencies = append([]string(nil), family.MemberDependencies...) - family.Inputs = cloneArtifactInputs(family.Inputs) - family.Vars = cloneArtifactVars(family.Vars) - if len(family.MemberVars) > 0 { - memberVars := make(map[string]string, len(family.MemberVars)) - for name, selector := range family.MemberVars { - memberVars[name] = selector - } - family.MemberVars = memberVars - } - family.Publish = cloneArtifactFamilyPublish(family.Publish) - out[key] = family - } - return out -} - func cloneArtifactFamilyPublish(in *ScriptoriumArtifactFamilyPublishConfig) *ScriptoriumArtifactFamilyPublishConfig { if in == nil { return nil diff --git a/internal/config/artifact_families_test.go b/internal/config/artifact_families_test.go index 36941e7..1d88319 100644 --- a/internal/config/artifact_families_test.go +++ b/internal/config/artifact_families_test.go @@ -68,15 +68,15 @@ characters: if err := Validate(cfg); err != nil { t.Fatalf("Validate() error = %v", err) } - if len(cfg.Pipeline.Scriptorium.ArtifactFamilies) != 0 { - t.Fatalf("adapter-facing artifact families = %#v, want none", cfg.Pipeline.Scriptorium.ArtifactFamilies) + if len(cfg.Pipeline.Scriptorium.ArtifactFamilies) != 2 { + t.Fatalf("authored artifact families = %#v, want both declarations", cfg.Pipeline.Scriptorium.ArtifactFamilies) } - keys := sortedArtifactKeys(cfg.Pipeline.Scriptorium.Artifacts) + keys := sortedArtifactKeys(cfg.ArtifactCatalog.Artifacts) wantKeys := []string{"character_items_alpha", "character_items_zeta", "character_meta_alpha", "character_meta_zeta"} if !reflect.DeepEqual(keys, wantKeys) { t.Fatalf("artifact keys = %#v, want %#v", keys, wantKeys) } - alpha := cfg.Pipeline.Scriptorium.Artifacts["character_items_alpha"] + alpha := cfg.ArtifactCatalog.Artifacts["character_items_alpha"] if alpha.Enabled || alpha.OutputPath != "artifacts/characters/alpha/items.md" { t.Fatalf("alpha artifact = %#v", alpha) } @@ -85,11 +85,11 @@ characters: }) { t.Fatalf("alpha vars = %#v", alpha.Vars) } - zeta := cfg.Pipeline.Scriptorium.Artifacts["character_items_zeta"] + zeta := cfg.ArtifactCatalog.Artifacts["character_items_zeta"] if got := zeta.Vars["classes"]; got != "wizard 8 / fighter" { t.Fatalf("zeta class summary = %#v", got) } - catalog := ArtifactFamilies(cfg.Pipeline) + catalog := ArtifactFamilies(cfg.ArtifactCatalog) if got, want := catalog.Families["character_meta"].Sources, []string{absolutePath(t, pipelinePath)}; !reflect.DeepEqual(got, want) { t.Fatalf("family sources = %#v, want %#v", got, want) } @@ -120,7 +120,7 @@ characters: if err != nil { t.Fatalf("reordered LoadWithSessionOptions() error = %v", err) } - if !reflect.DeepEqual(cfg.Pipeline.Scriptorium.Artifacts, again.Pipeline.Scriptorium.Artifacts) || !reflect.DeepEqual(ArtifactFamilies(cfg.Pipeline), ArtifactFamilies(again.Pipeline)) || firstDigest != EffectivePipelineDigest(again.Pipeline) { + if !reflect.DeepEqual(cfg.ArtifactCatalog.Artifacts, again.ArtifactCatalog.Artifacts) || !reflect.DeepEqual(ArtifactFamilies(cfg.ArtifactCatalog), ArtifactFamilies(again.ArtifactCatalog)) || firstDigest != EffectivePipelineDigest(again.Pipeline) { t.Fatalf("reordered source maps changed expansion") } } @@ -189,12 +189,11 @@ func TestArtifactFamiliesRejectGeneratedKeyAndOutputCollisions(t *testing.T) { } { t.Run(test.name, func(t *testing.T) { pipeline := &PipelineConfig{ - Scriptorium: &ScriptoriumConfig{Artifacts: test.artifacts}, - resolution: &pipelineResolutionMetadata{artifactFamilies: map[string]ScriptoriumArtifactFamilyConfig{"character_meta": base}}, + Scriptorium: &ScriptoriumConfig{Artifacts: test.artifacts, ArtifactFamilies: map[string]ScriptoriumArtifactFamilyConfig{"character_meta": base}}, } - err := expandPipelineArtifactFamilies(pipeline, ResolvedParty{Canonical: document}) + _, err := DeriveArtifactCatalog(pipeline, ResolvedParty{Canonical: document}) if err == nil || !strings.Contains(err.Error(), test.wantError) { - t.Fatalf("expandPipelineArtifactFamilies() error = %v, want %q", err, test.wantError) + t.Fatalf("DeriveArtifactCatalog() error = %v, want %q", err, test.wantError) } }) } @@ -232,18 +231,18 @@ characters: if err != nil { t.Fatal(err) } - items := cfg.Pipeline.Scriptorium.Artifacts["character_items_arannis"] + items := cfg.ArtifactCatalog.Artifacts["character_items_arannis"] if !reflect.DeepEqual(items.DependsOn, []string{"character_meta_arannis", "session_recap"}) { t.Fatalf("member dependencies = %#v", items.DependsOn) } if got := items.Inputs["prior_meta"].Source; got != "narratio.artifact.character_meta_arannis" { t.Fatalf("rewritten member source = %q", got) } - catalog := ArtifactFamilies(cfg.Pipeline) + catalog := ArtifactFamilies(cfg.ArtifactCatalog) if got := catalog.Members["character_items_arannis"]; !reflect.DeepEqual(got.Dependencies, items.DependsOn) || got.Inputs["prior_meta"] != "narratio.artifact.character_meta_arannis" { t.Fatalf("member provenance = %#v", got) } - for key, artifact := range cfg.Pipeline.Scriptorium.Artifacts { + for key, artifact := range cfg.ArtifactCatalog.Artifacts { for name, input := range artifact.Inputs { if strings.Contains(input.Source, "narratio.member_artifact.") { t.Fatalf("unresolved source at %s.%s = %q", key, name, input.Source) @@ -286,8 +285,7 @@ func TestArtifactFamiliesRejectInvalidMemberDependenciesAndSources(t *testing.T) "explicit": {Inputs: map[string]ScriptoriumInputConfig{ "bad": {Source: "narratio.member_artifact.character_meta"}, }}, - }}, - resolution: &pipelineResolutionMetadata{artifactFamilies: map[string]ScriptoriumArtifactFamilyConfig{ + }, ArtifactFamilies: map[string]ScriptoriumArtifactFamilyConfig{ "character_meta": {ForEach: partyCharactersFamilySource, OutputPathPattern: "artifacts/{character_id}.md"}, }}, } @@ -295,12 +293,11 @@ func TestArtifactFamiliesRejectInvalidMemberDependenciesAndSources(t *testing.T) if err != nil { t.Fatal(err) } - if err := expandPipelineArtifactFamilies(pipeline, ResolvedParty{Canonical: document}); err == nil || !strings.Contains(err.Error(), "outside an artifact family") { + if _, err := DeriveArtifactCatalog(pipeline, ResolvedParty{Canonical: document}); err == nil || !strings.Contains(err.Error(), "outside an artifact family") { t.Fatalf("concrete member source error = %v", err) } pipeline.Scriptorium.Artifacts["explicit"] = ScriptoriumArtifactConfig{Inputs: map[string]ScriptoriumInputConfig{"bad": {Source: "narratio.member_artifact."}}} - pipeline.resolution.artifactFamiliesExpanded = false - if err := expandPipelineArtifactFamilies(pipeline, ResolvedParty{Canonical: document}); err == nil || !strings.Contains(err.Error(), "malformed member artifact source") { + if _, err := DeriveArtifactCatalog(pipeline, ResolvedParty{Canonical: document}); err == nil || !strings.Contains(err.Error(), "malformed member artifact source") { t.Fatalf("malformed concrete member source error = %v", err) } } @@ -319,16 +316,17 @@ func TestFamilyPublishRulesExpandToConcreteArtifacts(t *testing.T) { }, Members: map[string]ArtifactFamilyMemberOrigin{ "character_meta_alpha": {CharacterID: "alpha"}, "character_meta_zeta": {CharacterID: "zeta"}, }} - if err := expandFamilyPublishRules(cfg, catalog); err != nil { + derived := &ArtifactCatalog{Artifacts: cfg.Scriptorium.Artifacts, Families: catalog} + if err := deriveFamilyPublishRules(cfg, derived); err != nil { t.Fatal(err) } - if got := cfg.Publish.Outputs; len(got) != 2 || got[0].Source != "narratio.artifact.character_meta_alpha" || got[0].Dest != "published/alpha.md" || got[0].Required == nil || !*got[0].Required { + if got := derived.PublishOutputs; len(got) != 2 || got[0].Source != "narratio.artifact.character_meta_alpha" || got[0].Dest != "published/alpha.md" || got[0].Required == nil || !*got[0].Required { t.Fatalf("generated publish rules = %#v", got) } cfg.Publish.Outputs = nil catalog.Families["character_meta"] = ArtifactFamilyOrigin{Members: []string{"character_meta_alpha"}, Publish: &ScriptoriumArtifactFamilyPublishConfig{Enabled: true}} cfg.Publish = nil - if err := expandFamilyPublishRules(cfg, catalog); err == nil || !strings.Contains(err.Error(), "requires pipeline.publish") { + if err := deriveFamilyPublishRules(cfg, derived); err == nil || !strings.Contains(err.Error(), "requires pipeline.publish") { t.Fatalf("missing publish error = %v", err) } } @@ -381,7 +379,7 @@ whisperx: "character_summary_alice": "artifacts/characters/alice/summary.md", "character_notes_alice": "artifacts/characters/alice/notes.md", } { - artifact, ok := cfg.Pipeline.Scriptorium.Artifacts[key] + artifact, ok := cfg.ArtifactCatalog.Artifacts[key] if !ok { t.Fatalf("inherited family member %q is missing", key) } @@ -394,7 +392,7 @@ whisperx: "narratio.artifact.character_summary_alice": "published/characters/alice/summary.md", "narratio.artifact.character_notes_alice": "published/characters/alice/notes.md", } - for _, rule := range cfg.Pipeline.Publish.Outputs { + for _, rule := range cfg.ArtifactCatalog.PublishOutputs { if want, ok := wantPublish[rule.Source]; ok { if rule.Dest != want { t.Errorf("family publish destination for %q = %q, want %q", rule.Source, rule.Dest, want) @@ -575,15 +573,11 @@ publish: if err != nil { t.Fatalf("LoadWithSessionOptions() error = %v", err) } - if got := cfg.Pipeline.Publish.Outputs[0].Dest; got != test.wantDest { + if got := cfg.ArtifactCatalog.PublishOutputs[0].Dest; got != test.wantDest { t.Fatalf("resolved runtime destination = %q, want %q", got, test.wantDest) } - effective, err := MarshalEffectivePipeline(cfg.Pipeline) - if err != nil { - t.Fatal(err) - } - if !strings.Contains(string(effective), "dest: "+test.wantDest+"\n") { - t.Fatalf("effective pipeline omitted resolved destination:\n%s", effective) + if got := cfg.Pipeline.Publish.Outputs[0].Dest; got != test.dest { + t.Fatalf("catalog derivation changed authored destination: %q, want %q", got, test.dest) } }) } diff --git a/internal/config/catalog_derivation_test.go b/internal/config/catalog_derivation_test.go new file mode 100644 index 0000000..65b8ef8 --- /dev/null +++ b/internal/config/catalog_derivation_test.go @@ -0,0 +1,125 @@ +package config + +import ( + "bytes" + "encoding/json" + "path/filepath" + "reflect" + "strings" + "testing" +) + +func TestCatalogDerivationKeepsNativeInputsAndRostersIndependent(t *testing.T) { + dir := t.TempDir() + t.Chdir(dir) + pipelinePath, campaignPath, sessionPath := writeArtifactFamilyConfig(t, dir, artifactFamilyPipelineYAML(` + character_notes: + enabled: true + for_each: party.characters + prompt_id: notes + output_path_pattern: artifacts/{character_id}.md + member_vars: + player: player.name + publish: + enabled: true + required: true +`)) + writePipelineFixture(t, dir, "party.yml", canonicalPartyFixture) + explicit := "selected.yml" + writePipelineFixture(t, dir, explicit, `schema_version: narratio.party.v1 +characters: + other: + player: {name: Selected Player} + character: {name: Other, classes: [{name: ranger}]} +`) + pipeline, err := LoadPipeline(pipelinePath) + if err != nil { + t.Fatal(err) + } + campaign, err := LoadCampaign(campaignPath) + if err != nil { + t.Fatal(err) + } + beforePipeline, err := json.Marshal(pipeline) + if err != nil { + t.Fatal(err) + } + beforeCampaign, err := json.Marshal(campaign) + if err != nil { + t.Fatal(err) + } + var beforeShow bytes.Buffer + if err := pipeline.ConfigKitResult().WriteEffective(&beforeShow); err != nil { + t.Fatal(err) + } + defaultContext, err := LoadPipelineCampaign(pipelinePath, pipeline, campaignPath, campaign) + if err != nil { + t.Fatal(err) + } + selectedContext, err := LoadPipelineCampaignWithPartyFile(pipelinePath, pipeline, campaignPath, campaign, &explicit) + if err != nil { + t.Fatal(err) + } + selected := selectedContext.ArtifactCatalog + if len(selected.Artifacts) != 1 || selected.Artifacts["character_notes_other"].Vars["player"] != "Selected Player" { + t.Fatalf("selected catalog = %+v", selected) + } + if _, found := defaultContext.ArtifactCatalog.Artifacts["character_notes_other"]; found { + t.Fatal("second roster changed the first catalog") + } + if !strings.Contains(string(selectedContext.Party.Players), "Selected Player") || strings.Contains(string(defaultContext.Party.Players), "Selected Player") { + t.Fatal("players did not follow the independently selected roster") + } + if result := selectedContext.Party.Canonical.ConfigKitResult(); result == nil || result.Config.Characters["other"].Player.Name != "Selected Player" || result.Sources()[0].Path != filepath.Join(dir, explicit) { + t.Fatalf("party lost its actual selected native result: %+v", result) + } + afterPipeline, _ := json.Marshal(pipeline) + afterCampaign, _ := json.Marshal(campaign) + var afterShow bytes.Buffer + if err := pipeline.ConfigKitResult().WriteEffective(&afterShow); err != nil { + t.Fatal(err) + } + if !bytes.Equal(beforePipeline, afterPipeline) || !bytes.Equal(beforeCampaign, afterCampaign) || beforeShow.String() != afterShow.String() { + t.Fatal("catalog derivation changed completed native configuration") + } + if len(pipeline.Scriptorium.ArtifactFamilies) != 1 || len(pipeline.Scriptorium.Artifacts) != 0 { + t.Fatal("domain definitions leaked into pipeline configuration") + } + if len(selected.PublishOutputs) != len(pipeline.Publish.Outputs)+1 { + t.Fatal("family publication actions were not derived separately") + } + cfg, err := LoadSessionWithPipelineCampaignOptions(selectedContext, sessionPath, SessionLoadOptions{}) + if err != nil { + t.Fatal(err) + } + if err := Validate(cfg); err != nil { + t.Fatal(err) + } + if cfg.StableInputs.PartyFile.Path != filepath.Join(dir, explicit) || cfg.StableInputs.PartyFile.Source != "party_file" || cfg.Campaign.Inputs.PartyFile != filepath.Join(dir, "party.yml") { + t.Fatalf("explicit party source or unchanged campaign default: %+v", cfg.StableInputs.PartyFile) + } + repeated, err := DeriveArtifactCatalog(pipeline, selectedContext.Party) + if err != nil || !reflect.DeepEqual(selected, repeated) { + t.Fatalf("repeated derivation changed catalog: %v", err) + } +} + +func TestExplicitPartySelectionNeverFallsBack(t *testing.T) { + dir := t.TempDir() + campaignPath := writePipelineFixture(t, dir, "campaign.yml", "campaign_id: campaign\ninputs: {speakers_file: speakers.yml, autocorrect_file: autocorrect.yml, glossary_file: glossary.yml, party_file: party.yml}\n") + writePipelineFixture(t, dir, "party.yml", canonicalPartyFixture) + campaign, err := LoadCampaign(campaignPath) + if err != nil { + t.Fatal(err) + } + invalid := writePipelineFixture(t, dir, "invalid.yml", "schema_version: invalid\n") + for _, path := range []string{"", filepath.Join(dir, "missing.yml"), invalid} { + if _, err := ResolveParty(campaignPath, campaign, &path); err == nil { + t.Fatalf("explicit party %q fell back", path) + } + } + path := filepath.Join(dir, "party.yml") + if party, err := ResolveParty("", nil, &path); err != nil || party.Canonical.ConfigKitResult() == nil { + t.Fatalf("exact party selection acquired unrelated campaign context: %v", err) + } +} diff --git a/internal/config/config.go b/internal/config/config.go index cb85991..f1a5213 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -14,9 +14,10 @@ type Config struct { CampaignDocument *CampaignConfig SessionDocument *SessionConfig - StableInputs ResolvedStableInputs - SessionSource SessionSource - Party ResolvedParty + StableInputs ResolvedStableInputs + SessionSource SessionSource + Party ResolvedParty + ArtifactCatalog *ArtifactCatalog } // PipelineConfig contains durable pipeline-level settings. @@ -37,16 +38,24 @@ type PipelineConfig struct { Notarius *NotariusConfig `yaml:"notarius" json:"notarius"` Notification NotificationConfig `yaml:"notification" json:"notification"` - resolution *pipelineResolutionMetadata `yaml:"-" json:"-"` - familyCatalog ArtifactFamilyCatalog `yaml:"-" json:"-"` + resolution *pipelineResolutionMetadata `yaml:"-" json:"-"` } -// ArtifactFamilies returns a copy of runtime-only expansion provenance. -func ArtifactFamilies(cfg *PipelineConfig) ArtifactFamilyCatalog { - if cfg == nil { +// ArtifactCatalog contains domain products derived from completed pipeline +// configuration and one selected canonical roster. +type ArtifactCatalog struct { + Artifacts map[string]ScriptoriumArtifactConfig + Families ArtifactFamilyCatalog + PublishOutputs []PublishOutputRule + Records []EffectiveArtifactRecord +} + +// ArtifactFamilies returns a copy of the derived family/member provenance. +func ArtifactFamilies(catalog *ArtifactCatalog) ArtifactFamilyCatalog { + if catalog == nil { return ArtifactFamilyCatalog{} } - return cloneArtifactFamilyCatalog(cfg.familyCatalog) + return cloneArtifactFamilyCatalog(catalog.Families) } // CampaignsConfig configures the local campaign registry. @@ -350,8 +359,7 @@ type SessionAudioS3Input struct { Prefix string `yaml:"prefix" json:"prefix"` } -// ResolvedStableInputs records where stable input file paths came from after -// campaign/session merge. +// ResolvedStableInputs records the origins of completed stable input paths. type ResolvedStableInputs struct { SpeakersFile ResolvedInputFile AutocorrectFile ResolvedInputFile @@ -360,19 +368,20 @@ type ResolvedStableInputs struct { SpellCatalogFile ResolvedInputFile } -// ResolvedInputFile records one merged config path and its source config file. +// ResolvedInputFile records one effective input path and its declaring source. type ResolvedInputFile struct { Path string ConfigPath string Source string } -// ResolvedParty records the campaign-owned canonical party and its non-secret +// ResolvedParty records the selected canonical party and its non-secret // source provenance. It is runtime-only and must never be copied into manifests // as raw party content. type ResolvedParty struct { Source PartySource Canonical *CanonicalParty + Players []byte } // PartySource identifies the selected party input without retaining its raw diff --git a/internal/config/effective_pipeline.go b/internal/config/effective_pipeline.go index a88907f..ee1b89c 100644 --- a/internal/config/effective_pipeline.go +++ b/internal/config/effective_pipeline.go @@ -36,9 +36,7 @@ func NormalizedConfigurationPath(path string) string { } // EffectivePipelineSourceRecord identifies one effective logical field and a -// safe source that contributed to it. Generated values intentionally have two -// records: their family declaration and the canonical party that supplied the -// member-specific value. +// safe source that contributed to it. type EffectivePipelineSourceRecord struct { Path string Role string @@ -102,8 +100,8 @@ func EffectivePipelineValues(cfg *PipelineConfig) ([]EffectivePipelineValueRecor return projectionValueRecords(projectEffectivePipeline(cfg)) } -// EffectivePipelineSources projects pipeline ownership after defaults and -// optional family expansion. It never includes effective values or raw secret +// EffectivePipelineSources projects pipeline ownership after resolution. +// It never includes effective values or raw secret // material, only logical paths and source identifiers. func EffectivePipelineSources(cfg *PipelineConfig, party ResolvedParty) ([]EffectivePipelineSourceRecord, error) { if cfg == nil { @@ -121,8 +119,6 @@ func EffectivePipelineSources(cfg *PipelineConfig, party ResolvedParty) ([]Effec if err != nil { return nil, err } - families := ArtifactFamilies(cfg) - partySources := partyCharacterSourceLookup(party) publishCount := 0 if cfg.Publish != nil { publishCount = len(cfg.Publish.Outputs) @@ -132,13 +128,9 @@ func EffectivePipelineSources(cfg *PipelineConfig, party ResolvedParty) ([]Effec if path == "publish.outputs" { continue } - if familyKey, ok := generatedArtifactFamilyForPath(path, families); ok { - records = appendGeneratedArtifactSources(records, path, familyKey, families, owners, partySources) - continue - } records = appendPipelineOwners(records, path, owners[path], cfg) } - records = appendPublishOutputSources(records, cfg, families, party, owners) + records = appendPublishOutputSources(records, cfg, owners) sort.Slice(records, func(left, right int) bool { if records[left].Path != records[right].Path { return records[left].Path < records[right].Path @@ -404,25 +396,12 @@ func appendPipelineOwners(records []EffectivePipelineSourceRecord, path string, return records } -func appendPublishOutputSources(records []EffectivePipelineSourceRecord, cfg *PipelineConfig, families ArtifactFamilyCatalog, party ResolvedParty, owners map[string][]string) []EffectivePipelineSourceRecord { +func appendPublishOutputSources(records []EffectivePipelineSourceRecord, cfg *PipelineConfig, owners map[string][]string) []EffectivePipelineSourceRecord { if cfg == nil || cfg.Publish == nil { return records } - generated := make(map[string]string) - for familyKey, family := range families.Families { - if family.Publish == nil || !family.Publish.Enabled { - continue - } - for _, key := range family.Members { - generated["narratio.artifact."+key] = familyKey - } - } - for index, output := range cfg.Publish.Outputs { + for index := range cfg.Publish.Outputs { path := fmt.Sprintf("publish.outputs[%d]", index) - if familyKey, ok := generated[strings.TrimSpace(output.Source)]; ok { - records = appendGeneratedPublishSources(records, path, familyKey, families, owners, party) - continue - } records = appendPipelineOwners(records, path, owners["publish.outputs"], cfg) } return records diff --git a/internal/config/load.go b/internal/config/load.go index 9fc325c..2d258c9 100644 --- a/internal/config/load.go +++ b/internal/config/load.go @@ -54,7 +54,6 @@ func finalizeLoadedPipeline(cfg *PipelineConfig) (*PipelineConfig, error) { if err := finalizePipelineResolution(cfg); err != nil { return nil, fmt.Errorf("load pipeline config: %w", err) } - retainArtifactFamilyDeclarations(cfg) return cfg, nil } @@ -156,24 +155,31 @@ func LoadWithSessionOptions(pipelinePath, campaignPath, sessionPath string, sess // subsequent local or remote session resolution. It prevents a command from // reloading the root pipeline after campaign selection. type LoadedPipelineCampaign struct { - PipelinePath string - Pipeline *PipelineConfig - CampaignPath string - Campaign *CampaignConfig - Party ResolvedParty + PipelinePath string + Pipeline *PipelineConfig + CampaignPath string + Campaign *CampaignConfig + Party ResolvedParty + ArtifactCatalog *ArtifactCatalog } // LoadPipelineCampaign combines already loaded pipeline and campaign documents // with their campaign-owned party source. Callers that later resolve a session // retain this context rather than independently reimplementing party loading. func LoadPipelineCampaign(pipelinePath string, pipeline *PipelineConfig, campaignPath string, campaign *CampaignConfig) (LoadedPipelineCampaign, error) { + return LoadPipelineCampaignWithPartyFile(pipelinePath, pipeline, campaignPath, campaign, nil) +} + +// LoadPipelineCampaignWithPartyFile derives domain context using an explicit +// invocation-relative roster file or the campaign's default when omitted. +func LoadPipelineCampaignWithPartyFile(pipelinePath string, pipeline *PipelineConfig, campaignPath string, campaign *CampaignConfig, partyFile *string) (LoadedPipelineCampaign, error) { if pipeline == nil { return LoadedPipelineCampaign{}, fmt.Errorf("pipeline config is required") } if campaign == nil { return LoadedPipelineCampaign{}, fmt.Errorf("campaign config is required") } - party, err := resolveCampaignParty(campaignPath, campaign) + party, err := ResolveParty(campaignPath, campaign, partyFile) if err != nil { return LoadedPipelineCampaign{}, err } @@ -181,9 +187,8 @@ func LoadPipelineCampaign(pipelinePath string, pipeline *PipelineConfig, campaig } // LoadPipelineCampaignWithParty combines an already loaded pipeline and -// campaign with one already resolved campaign-owned party. It is useful when -// more than one independently resolved pipeline must be expanded against the -// exact same party document. +// campaign with one already resolved party. Independently loaded pipelines can +// derive their catalogs against the same selected roster. func LoadPipelineCampaignWithParty(pipelinePath string, pipeline *PipelineConfig, campaignPath string, campaign *CampaignConfig, party ResolvedParty) (LoadedPipelineCampaign, error) { if pipeline == nil { return LoadedPipelineCampaign{}, fmt.Errorf("pipeline config is required") @@ -194,15 +199,24 @@ func LoadPipelineCampaignWithParty(pipelinePath string, pipeline *PipelineConfig if party.Canonical == nil { return LoadedPipelineCampaign{}, fmt.Errorf("resolved campaign party is required") } - if err := expandPipelineArtifactFamilies(pipeline, party); err != nil { + if party.Players == nil { + players, err := party.Canonical.PlayersYAML() + if err != nil { + return LoadedPipelineCampaign{}, err + } + party.Players = players + } + catalog, err := DeriveArtifactCatalog(pipeline, party) + if err != nil { return LoadedPipelineCampaign{}, err } return LoadedPipelineCampaign{ - PipelinePath: pipelinePath, - Pipeline: pipeline, - CampaignPath: campaignPath, - Campaign: campaign, - Party: party, + PipelinePath: pipelinePath, + Pipeline: pipeline, + CampaignPath: campaignPath, + Campaign: campaign, + Party: party, + ArtifactCatalog: catalog, }, nil } @@ -240,14 +254,15 @@ func ResolveLoadedPipelineCampaign(loaded LoadedPipelineCampaign, sessionPath st loaded.Party = party } cfg := &Config{ - Pipeline: loaded.Pipeline, - Campaign: loaded.Campaign, - Session: sessionCfg, - PipelinePath: loaded.PipelinePath, - CampaignPath: loaded.CampaignPath, - SessionPath: sessionPath, - SessionSource: sessionSource, - Party: loaded.Party, + Pipeline: loaded.Pipeline, + Campaign: loaded.Campaign, + Session: sessionCfg, + PipelinePath: loaded.PipelinePath, + CampaignPath: loaded.CampaignPath, + SessionPath: sessionPath, + SessionSource: sessionSource, + Party: loaded.Party, + ArtifactCatalog: loaded.ArtifactCatalog, } cfg.CampaignDocument = loaded.Campaign cfg.SessionDocument = sessionCfg @@ -265,6 +280,7 @@ func ResolveLoadedPipelineCampaign(loaded LoadedPipelineCampaign, sessionPath st if strings.TrimSpace(cfg.SessionSource.LocalPath) == "" { cfg.SessionSource.LocalPath = sessionPath } + stableInputs.PartyFile = ResolvedInputFile{Path: loaded.Party.Source.Path, ConfigPath: loaded.Party.Source.ConfigPath, Source: loaded.Party.Source.Source} cfg.StableInputs = stableInputs return cfg, nil } diff --git a/internal/config/load_validate_test.go b/internal/config/load_validate_test.go index d98bf7f..2fc70ac 100644 --- a/internal/config/load_validate_test.go +++ b/internal/config/load_validate_test.go @@ -406,17 +406,17 @@ func TestExamplesLoadAndValidate(t *testing.T) { "character_items_arannis", "character_items_brenna", } { - if _, exists := cfg.Pipeline.Scriptorium.Artifacts[key]; !exists { + if _, exists := cfg.ArtifactCatalog.Artifacts[key]; !exists { t.Fatalf("expanded artifact %q is absent", key) } } - if got := cfg.Pipeline.Scriptorium.Artifacts["character_items_arannis"].Inputs["character_meta"].Source; got != "narratio.artifact.character_meta_arannis" { + if got := cfg.ArtifactCatalog.Artifacts["character_items_arannis"].Inputs["character_meta"].Source; got != "narratio.artifact.character_meta_arannis" { t.Fatalf("same-member input source = %q", got) } - if got := cfg.Pipeline.Scriptorium.Artifacts["player_handout"].DependsOn; !reflect.DeepEqual(got, []string{"session_recap"}) { + if got := cfg.ArtifactCatalog.Artifacts["player_handout"].DependsOn; !reflect.DeepEqual(got, []string{"session_recap"}) { t.Fatalf("input-only artifact dependency = %#v", got) } - if got := cfg.Pipeline.Scriptorium.Artifacts["character_items_arannis"].DependsOn; !reflect.DeepEqual(got, []string{"character_meta_arannis"}) { + if got := cfg.ArtifactCatalog.Artifacts["character_items_arannis"].DependsOn; !reflect.DeepEqual(got, []string{"character_meta_arannis"}) { t.Fatalf("family input dependency = %#v", got) } if cfg.Party.Canonical == nil || len(cfg.Party.Canonical.Characters) != 2 { @@ -426,11 +426,11 @@ func TestExamplesLoadAndValidate(t *testing.T) { if characters[0].Player.Name != characters[1].Player.Name || len(characters[0].Character.Aliases) != 2 || len(characters[1].Character.Classes) != 2 { t.Fatalf("canonical party does not preserve repeated player, aliases, and multiclass data: %#v", characters) } - if len(cfg.Pipeline.Publish.Outputs) != 3 { - t.Fatalf("publish outputs = %#v, want transcript plus two family outputs", cfg.Pipeline.Publish.Outputs) + if len(cfg.ArtifactCatalog.PublishOutputs) != 3 { + t.Fatalf("publish outputs = %#v, want transcript plus two family outputs", cfg.ArtifactCatalog.PublishOutputs) } foundTranscript := false - for _, output := range cfg.Pipeline.Publish.Outputs { + for _, output := range cfg.ArtifactCatalog.PublishOutputs { if output.Source == "narratio.transcript.final_markdown" { foundTranscript = true if output.Required == nil || *output.Required != (profile.selection == "") { @@ -463,11 +463,11 @@ func TestExamplesLoadAndValidate(t *testing.T) { t.Fatalf("effective artifact catalog has %d records, want %d", len(catalog), wantCatalogSize) } if profile.selection == "testing" { - artifact, exists := cfg.Pipeline.Scriptorium.Artifacts["testing_notes"] + artifact, exists := cfg.ArtifactCatalog.Artifacts["testing_notes"] if !exists || artifact.Enabled { t.Fatalf("testing-only disabled artifact = %#v", artifact) } - recap := cfg.Pipeline.Scriptorium.Artifacts["session_recap"] + recap := cfg.ArtifactCatalog.Artifacts["session_recap"] if artifact.PromptID != "dnd.session_recap" || artifact.PromptID != recap.PromptID || artifact.ProfileID != recap.ProfileID || diff --git a/internal/config/notarius_test.go b/internal/config/notarius_test.go index 925fe25..65ba72c 100644 --- a/internal/config/notarius_test.go +++ b/internal/config/notarius_test.go @@ -806,10 +806,9 @@ func TestExtractionReferencesRequireDeclaredOutput(t *testing.T) { t.Run(tt.name, func(t *testing.T) { pipelinePath, sessionPath := writeConfigFiles(t, testPipelineBaseYAML+"\n"+tt.body, testSessionBaseYAML) cfg, err := Load(pipelinePath, sessionPath) - if err != nil { - t.Fatalf("Load() error = %v", err) + if err == nil { + err = Validate(cfg) } - err = Validate(cfg) if len(tt.wantErr) == 0 { if err != nil { t.Fatalf("Validate() error = %v", err) diff --git a/internal/config/party.go b/internal/config/party.go index f2faa0e..2e4f400 100644 --- a/internal/config/party.go +++ b/internal/config/party.go @@ -22,7 +22,16 @@ const ( // CanonicalParty is the normalized domain value for narratio.party.v1. type CanonicalParty struct { Characters []PartyCharacter - authoring *configkit.Result[partyDocument] + authoring *configkit.Result[PartyConfig] +} + +// ConfigKitResult returns the actual completed party load, independently of +// roster and players projections. +func (p *CanonicalParty) ConfigKitResult() *configkit.Result[PartyConfig] { + if p == nil { + return nil + } + return p.authoring } // PartyCharacter is one ordered character declaration from a canonical party. @@ -51,7 +60,8 @@ type PartyClass struct { Level *int } -type partyDocument struct { +// PartyConfig is the authored roster schema retained by ConfigKit. +type PartyConfig struct { SchemaVersion string `yaml:"schema_version"` Characters map[string]partyCharacter `yaml:"characters"` } @@ -95,14 +105,14 @@ func LoadParty(path string) (*CanonicalParty, error) { } func loadParty(source configkit.Source, imports bool) (*CanonicalParty, error) { - definition := configkit.Definition[partyDocument]{ + definition := configkit.Definition[PartyConfig]{ Version: &configkit.VersionRule{ Path: configkit.Keys("schema_version"), Check: validatePartyVersion, }, Validate: validatePartyDocument, } - result, err := configkit.Load(source, configkit.Options[partyDocument]{Imports: imports, Definition: definition}) + result, err := configkit.Load(source, configkit.Options[PartyConfig]{Imports: imports, Definition: definition}) if err != nil { return nil, describeConfigKitLoadError("party", err) } @@ -119,13 +129,13 @@ func validatePartyVersion(version configkit.Version, validation *configkit.Valid return nil } -func validatePartyDocument(document *partyDocument, validation *configkit.Validation) { +func validatePartyDocument(document *PartyConfig, validation *configkit.Validation) { if problem := firstPartyDomainError(document); problem != nil { validation.Error(problem.path, problem.message) } } -func firstPartyDomainError(document *partyDocument) *partyDomainError { +func firstPartyDomainError(document *PartyConfig) *partyDomainError { charactersPath := configkit.Keys("characters") if document == nil || len(document.Characters) == 0 { return &partyDomainError{path: charactersPath, message: "characters must be non-empty"} @@ -206,7 +216,7 @@ func partyNameAmbiguous(name string, existing []string) bool { return false } -func canonicalPartyFromResult(result *configkit.Result[partyDocument]) *CanonicalParty { +func canonicalPartyFromResult(result *configkit.Result[PartyConfig]) *CanonicalParty { type orderedCharacter struct { id string location configkit.Location diff --git a/internal/config/party_imports_test.go b/internal/config/party_imports_test.go index 3332419..760e444 100644 --- a/internal/config/party_imports_test.go +++ b/internal/config/party_imports_test.go @@ -94,7 +94,7 @@ func TestImportedPartyExpandsFamilyIdentities(t *testing.T) { t.Fatal(err) } for _, id := range []string{"character_meta_alpha", "character_meta_beta"} { - if _, ok := cfg.Pipeline.Scriptorium.Artifacts[id]; !ok { + if _, ok := cfg.ArtifactCatalog.Artifacts[id]; !ok { t.Fatalf("missing family member %q", id) } } diff --git a/internal/config/party_resolution.go b/internal/config/party_resolution.go index 8b22f93..b875ec5 100644 --- a/internal/config/party_resolution.go +++ b/internal/config/party_resolution.go @@ -24,7 +24,12 @@ func resolvePartyInput(input ResolvedInputFile) (ResolvedParty, error) { if err != nil { return ResolvedParty{}, fmt.Errorf("parse party input %q: %w", path, err) } + players, err := party.PlayersYAML() + if err != nil { + return ResolvedParty{}, err + } return ResolvedParty{ + Players: players, Source: PartySource{ Path: path, ConfigPath: configPath, @@ -59,3 +64,19 @@ func resolveCampaignParty(campaignPath string, campaign *CampaignConfig) (Resolv } return resolvePartyInput(input) } + +// ResolveParty loads the exact explicit party file, or the campaign's configured +// default. Explicit paths are relative to the invocation directory. +func ResolveParty(campaignPath string, campaign *CampaignConfig, explicitFile *string) (ResolvedParty, error) { + if explicitFile == nil { + return resolveCampaignParty(campaignPath, campaign) + } + if *explicitFile == "" { + return ResolvedParty{}, fmt.Errorf("explicit party file path is required") + } + path, err := filepath.Abs(*explicitFile) + if err != nil { + return ResolvedParty{}, fmt.Errorf("resolve explicit party file: %w", err) + } + return resolvePartyInput(ResolvedInputFile{Path: path, ConfigPath: path, Source: "party_file"}) +} diff --git a/internal/config/pipeline_configkit.go b/internal/config/pipeline_configkit.go index e4a9142..bc3d489 100644 --- a/internal/config/pipeline_configkit.go +++ b/internal/config/pipeline_configkit.go @@ -13,15 +13,13 @@ import ( ) type pipelineResolutionMetadata struct { - rootPath string - imports []string - sources []string - selectedOverlay *pipelineOverlaySelection - effectiveDigest string - artifactFamilies map[string]ScriptoriumArtifactFamilyConfig - artifactFamiliesExpanded bool - inspection *configkit.Result[effectivePipelineProjection] - authoring *configkit.Result[PipelineConfig] + rootPath string + imports []string + sources []string + selectedOverlay *pipelineOverlaySelection + effectiveDigest string + inspection *configkit.Result[effectivePipelineProjection] + authoring *configkit.Result[PipelineConfig] } // ConfigKitResult returns the authoritative native load result. Callers consume @@ -298,9 +296,6 @@ func pipelineMetadataPaths(cfg *PipelineConfig) ([]projectedPipelineValue, error return effective, nil } families := cfg.Scriptorium.ArtifactFamilies - if cfg.resolution != nil && len(cfg.resolution.artifactFamilies) != 0 { - families = cfg.resolution.artifactFamilies - } if len(families) == 0 { return effective, nil } diff --git a/internal/config/pipeline_configkit_test.go b/internal/config/pipeline_configkit_test.go index fccd114..7466f04 100644 --- a/internal/config/pipeline_configkit_test.go +++ b/internal/config/pipeline_configkit_test.go @@ -129,12 +129,12 @@ whisperx: t.Fatalf("load disjoint contributions: %v", err) } if test.name == "artifact" { - artifact := cfg.Pipeline.Scriptorium.Artifacts["recap"] + artifact := cfg.ArtifactCatalog.Artifacts["recap"] if !artifact.Enabled || artifact.PromptID != "dnd.recap" || artifact.OutputPath != "artifacts/recap.md" { t.Fatalf("composed artifact = %#v", artifact) } } else { - artifact := cfg.Pipeline.Scriptorium.Artifacts["recap_alice"] + artifact := cfg.ArtifactCatalog.Artifacts["recap_alice"] if !artifact.Enabled || artifact.PromptID != "dnd.recap" || artifact.OutputPath != "artifacts/alice.md" { t.Fatalf("composed artifact family member = %#v", artifact) } @@ -145,11 +145,11 @@ whisperx: if err != nil { t.Fatalf("load replacement overlay: %v", err) } - if test.name == "artifact" && cfg.Pipeline.Scriptorium.Artifacts["recap"].OutputPath != "artifacts/replaced.md" { - t.Fatalf("overlay artifact replacement = %#v", cfg.Pipeline.Scriptorium.Artifacts["recap"]) + if test.name == "artifact" && cfg.ArtifactCatalog.Artifacts["recap"].OutputPath != "artifacts/replaced.md" { + t.Fatalf("overlay artifact replacement = %#v", cfg.ArtifactCatalog.Artifacts["recap"]) } - if test.name == "artifact family" && cfg.Pipeline.Scriptorium.Artifacts["recap_alice"].OutputPath != "artifacts/alice_replaced.md" { - t.Fatalf("overlay family replacement = %#v", cfg.Pipeline.Scriptorium.Artifacts["recap_alice"]) + if test.name == "artifact family" && cfg.ArtifactCatalog.Artifacts["recap_alice"].OutputPath != "artifacts/alice_replaced.md" { + t.Fatalf("overlay family replacement = %#v", cfg.ArtifactCatalog.Artifacts["recap_alice"]) } removal := "removal" @@ -157,8 +157,8 @@ whisperx: if err != nil { t.Fatalf("load removal overlay: %v", err) } - if len(cfg.Pipeline.Scriptorium.Artifacts) != 0 { - t.Fatalf("overlay left artifacts after removal: %#v", cfg.Pipeline.Scriptorium.Artifacts) + if len(cfg.ArtifactCatalog.Artifacts) != 0 { + t.Fatalf("overlay left artifacts after removal: %#v", cfg.ArtifactCatalog.Artifacts) } }) } @@ -410,8 +410,8 @@ whisperx: if err != nil { t.Fatal(err) } - parent := cfg.Pipeline.Scriptorium.Artifacts["session_recap"] - child, ok := cfg.Pipeline.Scriptorium.Artifacts["session_notes"] + parent := cfg.ArtifactCatalog.Artifacts["session_recap"] + child, ok := cfg.ArtifactCatalog.Artifacts["session_notes"] if !ok { t.Fatal("inherited child artifact identity was not retained") } diff --git a/internal/config/scriptorium_test.go b/internal/config/scriptorium_test.go index a58470b..183e871 100644 --- a/internal/config/scriptorium_test.go +++ b/internal/config/scriptorium_test.go @@ -285,7 +285,7 @@ func TestScriptoriumLoadAndValidate(t *testing.T) { `, assert: func(t *testing.T, cfg *Config) { t.Helper() - artifact := cfg.Pipeline.Scriptorium.Artifacts["session_recap"] + artifact := cfg.ArtifactCatalog.Artifacts["session_recap"] if artifact.RenderDebug == nil || *artifact.RenderDebug != true { t.Fatalf("artifact render_debug = %#v, want true", artifact.RenderDebug) } @@ -320,8 +320,8 @@ func TestScriptoriumLoadAndValidate(t *testing.T) { if cfg.Pipeline.Scriptorium == nil { t.Fatal("scriptorium config should be present") } - if len(cfg.Pipeline.Scriptorium.Artifacts) != 2 { - t.Fatalf("scriptorium.artifacts count = %d, want 2", len(cfg.Pipeline.Scriptorium.Artifacts)) + if len(cfg.ArtifactCatalog.Artifacts) != 2 { + t.Fatalf("scriptorium.artifacts count = %d, want 2", len(cfg.ArtifactCatalog.Artifacts)) } }, }, @@ -418,7 +418,7 @@ func TestScriptoriumLoadAndValidate(t *testing.T) { `, assert: func(t *testing.T, cfg *Config) { t.Helper() - dependencies := cfg.Pipeline.Scriptorium.Artifacts["player_handout"].DependsOn + dependencies := cfg.ArtifactCatalog.Artifacts["player_handout"].DependsOn if len(dependencies) != 1 || dependencies[0] != "session_recap" { t.Fatalf("inferred dependencies = %#v, want [session_recap]", dependencies) } @@ -555,15 +555,12 @@ func TestScriptoriumLoadAndValidate(t *testing.T) { } return } - if err != nil { - t.Fatalf("Load() error = %v", err) + if err == nil { + if tt.assert != nil { + tt.assert(t, cfg) + } + err = Validate(cfg) } - - if tt.assert != nil { - tt.assert(t, cfg) - } - - err = Validate(cfg) if len(tt.wantValidateErr) > 0 { if err == nil { t.Fatalf("expected validation error containing %q, got nil", tt.wantValidateErr) @@ -591,10 +588,10 @@ func TestScriptoriumDiagnosticsAreIndependentOfMapInsertionOrder(t *testing.T) { secondArtifacts["alpha"] = invalidArtifact secondArtifacts["beta"] = invalidArtifact - firstErr := validateScriptorium(&ScriptoriumConfig{Binary: "scriptorium", Artifacts: firstArtifacts}, nil) - secondErr := validateScriptorium(&ScriptoriumConfig{Binary: "scriptorium", Artifacts: secondArtifacts}, nil) + firstErr := validateConcreteArtifacts(firstArtifacts, nil) + secondErr := validateConcreteArtifacts(secondArtifacts, nil) if firstErr == nil || secondErr == nil { - t.Fatalf("validateScriptorium() errors = %v / %v, want validation failures", firstErr, secondErr) + t.Fatalf("concrete artifact validation errors = %v / %v, want validation failures", firstErr, secondErr) } if firstErr.Error() != secondErr.Error() { t.Fatalf("equivalent maps produced different diagnostics:\nfirst: %v\nsecond: %v", firstErr, secondErr) @@ -621,10 +618,9 @@ scriptorium: ` pipelinePath, sessionPath := writeConfigFiles(t, pipelineYAML, testSessionBaseYAML) cfg, err := Load(pipelinePath, sessionPath) - if err != nil { - t.Fatalf("Load() error = %v", err) + if err == nil { + err = Validate(cfg) } - err = Validate(cfg) if err == nil || !strings.Contains(err.Error(), "pipeline.scriptorium.artifacts.session_recap.inputs.transcript.source") || !strings.Contains(err.Error(), "unsupported") { t.Fatalf("Validate() error = %v, want source field and unsupported category", err) } diff --git a/internal/config/storage_publish_test.go b/internal/config/storage_publish_test.go index 6981c3b..c64f12a 100644 --- a/internal/config/storage_publish_test.go +++ b/internal/config/storage_publish_test.go @@ -266,10 +266,9 @@ inputs: } pipelinePath, sessionPath := writeConfigFiles(t, pipelineYAML, sessionYAML) cfg, err := Load(pipelinePath, sessionPath) - if err != nil { - t.Fatalf("Load() error = %v", err) + if err == nil { + err = Validate(cfg) } - err = Validate(cfg) if tt.wantErr != "" { if err == nil || !strings.Contains(err.Error(), tt.wantErr) { t.Fatalf("Validate() error = %v, want %q", err, tt.wantErr) @@ -460,10 +459,9 @@ publish: pipelinePath, sessionPath := writeConfigFiles(t, pipelineYAML, testSessionBaseYAML) cfg, err := Load(pipelinePath, sessionPath) - if err != nil { - t.Fatalf("Load() error = %v", err) + if err == nil { + err = Validate(cfg) } - err = Validate(cfg) if err == nil || !strings.Contains(err.Error(), tt.wantErr) { t.Fatalf("Validate() error = %v, want to contain %q", err, tt.wantErr) } @@ -481,10 +479,9 @@ publish: ` pipelinePath, sessionPath := writeConfigFiles(t, pipelineYAML, testSessionBaseYAML) cfg, err := Load(pipelinePath, sessionPath) - if err != nil { - t.Fatalf("Load() error = %v", err) + if err == nil { + err = Validate(cfg) } - err = Validate(cfg) if err == nil || !strings.Contains(err.Error(), "pipeline.publish.outputs[0].source") || !strings.Contains(err.Error(), "unsupported") { t.Fatalf("Validate() error = %v, want source field and unsupported category", err) } diff --git a/internal/config/validate.go b/internal/config/validate.go index db61bd8..2f3b00d 100644 --- a/internal/config/validate.go +++ b/internal/config/validate.go @@ -34,6 +34,9 @@ func Validate(cfg *Config) error { if err := validateResolvedPartyInputs(cfg); err != nil { return fmt.Errorf("campaign/session config invalid: %w", err) } + if _, err := DeriveArtifactCatalog(cfg.Pipeline, cfg.Party); err != nil { + return err + } if err := validateCrossConfig(cfg.Pipeline, cfg.Session, cfg.StableInputs); err != nil { return fmt.Errorf("pipeline/session config invalid: %w", err) } @@ -79,9 +82,6 @@ func validatePipeline(cfg *PipelineConfig) error { if err := validateNotarius(cfg.Notarius, cfg.Scriptorium); err != nil { return err } - if err := validatePublish(cfg.Publish, cfg.Scriptorium, cfg.Notarius); err != nil { - return err - } if err := validateCleanupPublishPolicy(cfg); err != nil { return err } @@ -103,7 +103,7 @@ func validatePipeline(cfg *PipelineConfig) error { if err := validateRender(cfg.Render); err != nil { return err } - if err := validateScriptorium(cfg.Scriptorium, cfg.Notarius); err != nil { + if err := validateScriptoriumConfiguration(cfg.Scriptorium); err != nil { return err } if err := validateNotification(cfg.Notification); err != nil { diff --git a/internal/config/validate_core.go b/internal/config/validate_core.go index 821b9eb..1f1ec03 100644 --- a/internal/config/validate_core.go +++ b/internal/config/validate_core.go @@ -124,8 +124,8 @@ func validateResolvedPartyInputs(cfg *Config) error { if cfg.Party.Canonical == nil { return fmt.Errorf("canonical party data is required") } - if cfg.Party.Source.Source != "campaign_config" { - return fmt.Errorf("canonical party must be sourced by campaign_config") + if cfg.Party.Source.Source != "campaign_config" && cfg.Party.Source.Source != "party_file" { + return fmt.Errorf("canonical party must be sourced by campaign_config or an explicit party_file") } return nil } diff --git a/internal/config/validate_publish.go b/internal/config/validate_publish.go index 353e48e..5397125 100644 --- a/internal/config/validate_publish.go +++ b/internal/config/validate_publish.go @@ -69,14 +69,9 @@ func validateStorage(cfg StorageConfig) error { return nil } -func validatePublish(cfg *PublishConfig, scriptorium *ScriptoriumConfig, notarius *NotariusConfig) error { - if cfg == nil { - return nil - } - configuredOutputs := scriptoriumOutputPathMap(scriptorium) - extractionOutputs := notariusOutputKeySet(notarius) +func validatePublishedOutputs(outputs []PublishOutputRule, configuredOutputs map[string]string, extractionOutputs map[string]struct{}) error { seenDest := map[string]struct{}{} - for i, item := range cfg.Outputs { + for i, item := range outputs { prefix := fmt.Sprintf("pipeline.publish.outputs[%d]", i) source := strings.TrimSpace(item.Source) if source == "" { @@ -122,16 +117,18 @@ func validateCleanupPublishPolicy(cfg *PipelineConfig) error { } func scriptoriumOutputPathMap(scriptorium *ScriptoriumConfig) map[string]string { - out := map[string]string{} - if scriptorium == nil || len(scriptorium.Artifacts) == 0 { - return out + if scriptorium == nil { + return map[string]string{} } - for _, key := range sortedStringKeys(scriptorium.Artifacts) { - artifactCfg := scriptorium.Artifacts[key] - if !artifactpolicy.IsConfiguredKey(key) { - continue + return artifactOutputPathMap(scriptorium.Artifacts) +} + +func artifactOutputPathMap(artifacts map[string]ScriptoriumArtifactConfig) map[string]string { + out := make(map[string]string, len(artifacts)) + for _, key := range sortedStringKeys(artifacts) { + if artifactpolicy.IsConfiguredKey(key) { + out[strings.TrimSpace(key)] = strings.TrimSpace(artifacts[key].OutputPath) } - out[strings.TrimSpace(key)] = strings.TrimSpace(artifactCfg.OutputPath) } return out } diff --git a/internal/config/validate_scriptorium.go b/internal/config/validate_scriptorium.go index d2d3cf8..80ee8ab 100644 --- a/internal/config/validate_scriptorium.go +++ b/internal/config/validate_scriptorium.go @@ -9,7 +9,7 @@ import ( "gitea.maximumdirect.net/eric/narratio/internal/artifactpolicy" ) -func validateScriptorium(cfg *ScriptoriumConfig, notarius *NotariusConfig) error { +func validateScriptoriumConfiguration(cfg *ScriptoriumConfig) error { if cfg == nil { return nil } @@ -22,16 +22,26 @@ func validateScriptorium(cfg *ScriptoriumConfig, notarius *NotariusConfig) error if err := validateDuration("pipeline.scriptorium.timeout", cfg.Timeout); err != nil { return err } - - artifactNames, configuredArtifacts, err := validateScriptoriumArtifactKeys(cfg.Artifacts) + names, _, err := validateScriptoriumArtifactKeys(cfg.Artifacts) if err != nil { return err } - if err := validateScriptoriumDeclarations(cfg.Artifacts, artifactNames); err != nil { + if err := validateScriptoriumDeclarations(cfg.Artifacts, names); err != nil { + return err + } + return validateScriptoriumVariables(cfg.Artifacts, names) +} + +func validateConcreteArtifacts(artifacts map[string]ScriptoriumArtifactConfig, notarius *NotariusConfig) error { + artifactNames, configuredArtifacts, err := validateScriptoriumArtifactKeys(artifacts) + if err != nil { + return err + } + if err := validateScriptoriumDeclarations(artifacts, artifactNames); err != nil { return err } referencedArtifacts, err := validateScriptoriumDependenciesAndInputs( - cfg.Artifacts, + artifacts, artifactNames, configuredArtifacts, notariusOutputKeySet(notarius), @@ -39,13 +49,13 @@ func validateScriptorium(cfg *ScriptoriumConfig, notarius *NotariusConfig) error if err != nil { return err } - if err := validateScriptoriumVariables(cfg.Artifacts, artifactNames); err != nil { + if err := validateScriptoriumVariables(artifacts, artifactNames); err != nil { return err } - if err := validateScriptoriumReferencedOutputs(cfg.Artifacts, referencedArtifacts); err != nil { + if err := validateScriptoriumReferencedOutputs(artifacts, referencedArtifacts); err != nil { return err } - if err := ValidateScriptoriumArtifactDependencies(cfg.Artifacts); err != nil { + if err := ValidateScriptoriumArtifactDependencies(artifacts); err != nil { return err }