Use native configuration diff and source evidence

This commit is contained in:
2026-11-17 22:35:56 +00:00
parent ce661252d0
commit ebcc5b32a0
13 changed files with 277 additions and 111 deletions

View File

@@ -117,8 +117,10 @@ family declarations, and runtime provenance.
effective values. Its header identifies the root, ordered imports, selected effective values. Its header identifies the root, ordered imports, selected
overlay and its file, selected campaign, party source, and digest. The overlay and its file, selected campaign, party source, and digest. The
remaining tab-separated records are sorted as `path`, `role`, and `source`. remaining tab-separated records are sorted as `path`, `role`, and `source`.
Roles distinguish root, import, overlay, centralized default, campaign, party, Roles distinguish root, import, overlay, normalization, centralized default,
and generated family ownership. A generated party member has campaign, party, and generated family ownership. Records labeled
`empty_import` identify the source-local declaration path, selector, and
location of an optional import that selected no sources. A generated party member has
one family record and one party record at the same logical path. The output one family record and one party record at the same logical path. The output
never reads or prints secret values. never reads or prints secret values.
@@ -151,8 +153,10 @@ removed <path> <left-value>
changed <path> <left-value> <right-value> changed <path> <left-value> <right-value>
``` ```
Mappings are flattened to their logical field paths; lists remain one atomic Paths use JSON Pointer notation, with `~0` for `~` and `~1` for `/`. Native
value. The command compares defaulted concrete artifacts and publish rules, not comparison reports a changed mapping region as one value when a whole mapping
is added or removed; lists are compared as whole values. A `hidden_changed=true`
field indicates a change hidden by redaction. The command compares defaulted concrete artifacts and publish rules, not
overlay names, source-file layout, or formatting. It succeeds when differences overlay names, source-file layout, or formatting. It succeeds when differences
are found, making it suitable for review and migration checks. are found, making it suitable for review and migration checks.

View File

@@ -311,7 +311,7 @@ Test final family/publish expansion, inherited/expanded equivalence, large
integer variables, null/empty values, safe rendering, credential-reference integer variables, null/empty values, safe rendering, credential-reference
changes versus rotation, and no credential resolution during snapshot creation. changes versus rotation, and no credential resolution during snapshot creation.
## Stage 9: Adopt native diff and truthful operator source inspection ## Stage 9: Adopt native diff and truthful operator source inspection [x]
Read `internal/app/config_diff.go`, config command loaders/tests, Read `internal/app/config_diff.go`, config command loaders/tests,
`artifact_catalog.go`, and native Diff/source/history contracts. `artifact_catalog.go`, and native Diff/source/history contracts.

View File

@@ -272,7 +272,7 @@ func TestAssembledSplitBundleCommandsUseOneEffectiveFamilyConfiguration(t *testi
}, &diff); err != nil { }, &diff); err != nil {
t.Fatalf("compare profiles: %v", err) t.Fatalf("compare profiles: %v", err)
} }
if !strings.Contains(diff.String(), "audita.proposal_profile") || !strings.Contains(diff.String(), "character_items_arannis.profile_id") { if !strings.Contains(diff.String(), "/audita/proposal_profile") || !strings.Contains(diff.String(), "/character_items_arannis/profile_id") {
t.Fatalf("profile diff = %q, want proposal profile and expanded family changes", diff.String()) t.Fatalf("profile diff = %q, want proposal profile and expanded family changes", diff.String())
} }

View File

@@ -140,6 +140,11 @@ func configSourcesWithDependencies(_ context.Context, args []string, out io.Writ
return err return err
} }
} }
for _, selection := range config.EffectiveEmptyImports(resolved.Pipeline, resolved.Campaign) {
if _, err := fmt.Fprintf(out, "empty_import\t%s\t%s\t%s:%d:%d\n", selection.Path, selection.Selector, selection.Source, selection.Line, selection.Column); err != nil {
return err
}
}
return nil return nil
} }

View File

@@ -186,24 +186,24 @@ scriptorium:
} }
output := first.String() output := first.String()
for _, want := range []string{ for _, want := range []string{
"changed\taudita.modules\t[\"glossary\",\"grammar\"]\t[]\n", "changed\t/audita/modules\t[\"glossary\",\"grammar\"]\t[]\n",
"changed\tworkspace.cleanup_after_publish\ttrue\tfalse\n", "changed\t/workspace/cleanup_after_publish\ttrue\tfalse\n",
"changed\twhisperx.language\t\"en\"\t\"fr\"\n", "changed\t/whisperx/language\t\"en\"\t\"fr\"\n",
"removed\tscriptorium.artifacts.production_only.enabled\tfalse\n", "removed\t/scriptorium/artifacts/production_only\t{",
"added\tscriptorium.artifacts.testing_only.enabled\tfalse\n", "added\t/scriptorium/artifacts/testing_only\t{",
} { } {
if !strings.Contains(output, want) { if !strings.Contains(output, want) {
t.Fatalf("diff output missing %q:\n%s", want, output) t.Fatalf("diff output missing %q:\n%s", want, output)
} }
} }
if strings.Index(output, "audita.modules") > strings.Index(output, "workspace.cleanup_after_publish") { if strings.Index(output, "/audita/modules") > strings.Index(output, "/workspace/cleanup_after_publish") {
t.Fatalf("diff records are not sorted by path:\n%s", output) t.Fatalf("diff records are not sorted by path:\n%s", output)
} }
var reversed bytes.Buffer var reversed bytes.Buffer
if err := ConfigDiff(context.Background(), []string{"testing", "production", "--config", pipelinePath}, &reversed); err != nil { if err := ConfigDiff(context.Background(), []string{"testing", "production", "--config", pipelinePath}, &reversed); err != nil {
t.Fatalf("reversed ConfigDiff() error = %v", err) t.Fatalf("reversed ConfigDiff() error = %v", err)
} }
if !strings.Contains(reversed.String(), "changed\twhisperx.language\t\"fr\"\t\"en\"\n") { if !strings.Contains(reversed.String(), "changed\t/whisperx/language\t\"fr\"\t\"en\"\n") {
t.Fatalf("reversed diff did not independently resolve overlays:\n%s", reversed.String()) t.Fatalf("reversed diff did not independently resolve overlays:\n%s", reversed.String())
} }
} }
@@ -249,8 +249,8 @@ scriptorium:
t.Fatal(err) t.Fatal(err)
} }
for _, want := range []string{ for _, want := range []string{
"changed\taudita.modules\tnull\t[]\n", "changed\t/audita/modules\tnull\t[]\n",
"changed\tscriptorium.artifacts\tnull\t{}\n", "changed\t/scriptorium/artifacts\tnull\t{}\n",
} { } {
if !strings.Contains(diff.String(), want) { if !strings.Contains(diff.String(), want) {
t.Fatalf("diff output missing %q:\n%s", want, diff.String()) t.Fatalf("diff output missing %q:\n%s", want, diff.String())
@@ -289,9 +289,9 @@ func TestConfigDiffComparesExpandedFamiliesAndPublishRules(t *testing.T) {
} }
output := out.String() output := out.String()
for _, want := range []string{ for _, want := range []string{
"changed\tscriptorium.artifacts.character_note_arannis.enabled\tfalse\ttrue\n", "changed\t/scriptorium/artifacts/character_note_arannis/enabled\tfalse\ttrue\n",
"changed\tscriptorium.artifacts.character_note_arannis.vars.character_name\t\"Arannis\"\t\"wizard\"\n", "changed\t/scriptorium/artifacts/character_note_arannis/vars/character_name\t\"Arannis\"\t\"wizard\"\n",
"changed\tpublish.outputs\t", "changed\t/publish/outputs\t",
} { } {
if !strings.Contains(output, want) { if !strings.Contains(output, want) {
t.Fatalf("family diff output missing %q:\n%s", want, output) t.Fatalf("family diff output missing %q:\n%s", want, output)
@@ -486,7 +486,7 @@ func TestConfigCommandsInspectMaintainedSplitBundleWithoutRuntimeState(t *testin
if err := ConfigDiff(context.Background(), []string{"default", "testing", "--config", pipelinePath, "--campaign-file", campaignPath}, &diff); err != nil { if err := ConfigDiff(context.Background(), []string{"default", "testing", "--config", pipelinePath, "--campaign-file", campaignPath}, &diff); err != nil {
t.Fatalf("ConfigDiff() error = %v", err) t.Fatalf("ConfigDiff() error = %v", err)
} }
if !strings.Contains(diff.String(), "audita.proposal_profile") { if !strings.Contains(diff.String(), "/audita/proposal_profile") {
t.Fatalf("split bundle overlay diff = %q, want proposal profile change", diff.String()) t.Fatalf("split bundle overlay diff = %q, want proposal profile change", diff.String())
} }
if _, err := os.Stat(workspacePath); !os.IsNotExist(err) { if _, err := os.Stat(workspacePath); !os.IsNotExist(err) {

View File

@@ -2,14 +2,16 @@ package app
import ( import (
"context" "context"
"encoding/json"
"errors" "errors"
"flag" "flag"
"fmt" "fmt"
"io" "io"
"sort"
"strings" "strings"
"gitea.maximumdirect.net/eric/narratio/internal/config" "gitea.maximumdirect.net/eric/narratio/internal/config"
configkit "go.maximumdirect.net/configkit"
"gopkg.in/yaml.v3"
) )
type configDiffFlags struct { type configDiffFlags struct {
@@ -30,13 +32,6 @@ type configDiffResolved struct {
right *inspectionConfig right *inspectionConfig
} }
type configDiffRecord struct {
Kind string
Path string
Left string
Right string
}
// ConfigDiff compares two explicitly selected overlays through the same // ConfigDiff compares two explicitly selected overlays through the same
// read-only configuration resolution boundary used by config validate, show, // read-only configuration resolution boundary used by config validate, show,
// and sources. Differences describe normalized effective values rather than // and sources. Differences describe normalized effective values rather than
@@ -57,43 +52,42 @@ func configDiffWithDependencies(_ context.Context, args []string, out io.Writer,
if err != nil { if err != nil {
return fmt.Errorf("config diff: %w", err) return fmt.Errorf("config diff: %w", err)
} }
leftValues, err := config.EffectivePipelineValues(resolved.left.Pipeline) differences, err := config.DiffEffectivePipelines(resolved.left.Pipeline, resolved.right.Pipeline)
if err != nil {
return fmt.Errorf("config diff: project left effective configuration: %w", err)
}
rightValues, err := config.EffectivePipelineValues(resolved.right.Pipeline)
if err != nil {
return fmt.Errorf("config diff: project right effective configuration: %w", err)
}
records, err := diffEffectivePipelineValues(leftValues, rightValues)
if err != nil { if err != nil {
return fmt.Errorf("config diff: %w", err) return fmt.Errorf("config diff: %w", err)
} }
leftDigest := config.EffectivePipelineDigest(resolved.left.Pipeline) if len(differences) == 0 {
rightDigest := config.EffectivePipelineDigest(resolved.right.Pipeline)
if len(records) == 0 {
if leftDigest != rightDigest {
return fmt.Errorf("internal error: effective pipeline digests differ without a semantic difference")
}
_, err := fmt.Fprintln(out, "no differences") _, err := fmt.Fprintln(out, "no differences")
return err return err
} }
for _, record := range records { for _, difference := range differences {
switch record.Kind { kind := "changed"
case "added": if !difference.Left.Present {
if _, err := fmt.Fprintf(out, "added\t%s\t%s\n", record.Path, record.Right); err != nil { kind = "added"
}
if !difference.Right.Present {
kind = "removed"
}
fields := []string{kind, difference.Path.String()}
if difference.Left.Present {
value, err := compactSnapshot(difference.Left)
if err != nil {
return err return err
} }
case "removed": fields = append(fields, value)
if _, err := fmt.Fprintf(out, "removed\t%s\t%s\n", record.Path, record.Left); err != nil { }
if difference.Right.Present {
value, err := compactSnapshot(difference.Right)
if err != nil {
return err return err
} }
case "changed": fields = append(fields, value)
if _, err := fmt.Fprintf(out, "changed\t%s\t%s\t%s\n", record.Path, record.Left, record.Right); err != nil { }
return err if difference.HiddenChanged {
} fields = append(fields, "hidden_changed=true")
default: }
return fmt.Errorf("internal error: unsupported difference kind %q", record.Kind) if _, err := fmt.Fprintln(out, strings.Join(fields, "\t")); err != nil {
return err
} }
} }
return nil return nil
@@ -264,50 +258,14 @@ func resolveSharedDiffCampaignPath(left, right *config.PipelineConfig, flags con
return leftPath, nil return leftPath, nil
} }
func diffEffectivePipelineValues(left, right []config.EffectivePipelineValueRecord) ([]configDiffRecord, error) { func compactSnapshot(snapshot configkit.ValueSnapshot) (string, error) {
leftByPath, err := effectivePipelineValueMap("left", left) var value any
if err := yaml.Unmarshal([]byte(snapshot.YAML), &value); err != nil {
return "", fmt.Errorf("decode safe diff value: %w", err)
}
encoded, err := json.Marshal(value)
if err != nil { if err != nil {
return nil, err return "", fmt.Errorf("encode safe diff value: %w", err)
} }
rightByPath, err := effectivePipelineValueMap("right", right) return string(encoded), nil
if err != nil {
return nil, err
}
paths := make([]string, 0, len(leftByPath)+len(rightByPath))
seen := make(map[string]struct{}, len(leftByPath)+len(rightByPath))
for path := range leftByPath {
seen[path] = struct{}{}
paths = append(paths, path)
}
for path := range rightByPath {
if _, exists := seen[path]; !exists {
paths = append(paths, path)
}
}
sort.Strings(paths)
records := make([]configDiffRecord, 0)
for _, path := range paths {
leftValue, leftExists := leftByPath[path]
rightValue, rightExists := rightByPath[path]
switch {
case !leftExists:
records = append(records, configDiffRecord{Kind: "added", Path: path, Right: rightValue})
case !rightExists:
records = append(records, configDiffRecord{Kind: "removed", Path: path, Left: leftValue})
case leftValue != rightValue:
records = append(records, configDiffRecord{Kind: "changed", Path: path, Left: leftValue, Right: rightValue})
}
}
return records, nil
}
func effectivePipelineValueMap(side string, records []config.EffectivePipelineValueRecord) (map[string]string, error) {
values := make(map[string]string, len(records))
for _, record := range records {
if _, exists := values[record.Path]; exists {
return nil, fmt.Errorf("internal error: %s effective configuration has duplicate path %q", side, record.Path)
}
values[record.Path] = record.Value
}
return values, nil
} }

View File

@@ -0,0 +1,40 @@
package app
import (
"bytes"
"context"
"path/filepath"
"strings"
"testing"
)
func TestConfigDiffUsesEscapedPointersAndAtomicLists(t *testing.T) {
dir := t.TempDir()
root := filepath.Join(dir, "pipeline.yml")
mustWriteTestFile(t, root, "whisperx: {transcribe_url: 'https://example.test/transcribe'}\nscriptorium:\n artifacts:\n recap:\n enabled: false\n output_path: artifacts/recap.md\n vars: {'a/b~c': before}\naudita: {modules: [glossary, grammar]}\n")
mustWriteTestFile(t, filepath.Join(dir, "overlays", "changed.yml"), "scriptorium:\n artifacts:\n recap:\n vars: {'a/b~c': after}\naudita: {modules: [glossary, homophones]}\n")
var output bytes.Buffer
if err := ConfigDiff(context.Background(), []string{"default", "changed", "--config", root}, &output); err != nil {
t.Fatal(err)
}
for _, want := range []string{"changed\t/audita/modules\t[\"glossary\",\"grammar\"]\t[\"glossary\",\"homophones\"]", "changed\t/scriptorium/artifacts/recap/vars/a~1b~0c\t\"before\"\t\"after\""} {
if !strings.Contains(output.String(), want) {
t.Fatalf("diff lacks %q: %s", want, output.String())
}
}
}
func TestConfigSourcesReportsEmptyOptionalImportAndNormalization(t *testing.T) {
dir := t.TempDir()
root := filepath.Join(dir, "pipeline.yml")
mustWriteTestFile(t, root, "config:\n imports:\n - path: absent.yml\nworkspace: {root: ./work}\nwhisperx: {transcribe_url: 'https://example.test/transcribe'}\n")
var output bytes.Buffer
if err := ConfigSources(context.Background(), []string{"--config", root}, &output); err != nil {
t.Fatal(err)
}
for _, want := range []string{"empty_import\t/config/imports/0\tpath\t" + root, "workspace.root\tresolution\tresolution", "workspace.root\troot\t" + root} {
if !strings.Contains(output.String(), want) {
t.Fatalf("sources lack %q: %s", want, output.String())
}
}
}

View File

@@ -54,7 +54,7 @@ func EffectiveArtifactCatalog(cfg *PipelineConfig, party ResolvedParty) ([]Effec
record.FamilyKey = member.Family record.FamilyKey = member.Family
record.CharacterID = member.CharacterID record.CharacterID = member.CharacterID
record.FamilySources = append([]string(nil), cfg.familyCatalog.Families[member.Family].Sources...) record.FamilySources = append([]string(nil), cfg.familyCatalog.Families[member.Family].Sources...)
record.PartySource = party.Source.Path record.PartySource = strings.Join(partyCharacterSources(party, member.CharacterID), ",")
} else { } else {
record.DefinitionSources = artifactDefinitionSources(cfg, key) record.DefinitionSources = artifactDefinitionSources(cfg, key)
} }
@@ -64,6 +64,47 @@ func EffectiveArtifactCatalog(cfg *PipelineConfig, party ResolvedParty) ([]Effec
return records, nil return records, nil
} }
func partyCharacterSources(party ResolvedParty, id string) []string {
if party.Canonical == nil || party.Canonical.authoring == nil {
return nonEmptySortedStrings([]string{party.Source.Path})
}
result := party.Canonical.authoring
path := configkit.Keys("characters", id)
var ids []string
add := func(origin configkit.Origin) {
for _, location := range origin.Locations {
ids = append(ids, location.SourceID)
}
for _, step := range origin.Inheritance {
for _, location := range step.Locations {
ids = append(ids, location.SourceID)
}
}
}
if info, ok := result.Metadata().Lookup(path); ok {
add(info.Origin)
}
for _, change := range result.Metadata().History(path) {
if change.Origin.Layer == configkit.LayerMain || change.Origin.Layer == configkit.LayerOverlay {
add(change.Origin)
}
}
var sources []string
for _, id := range nonEmptySortedStrings(ids) {
if source, ok := result.Source(id); ok {
name := source.Path
if name == "" {
name = source.Label
}
sources = append(sources, name)
}
}
if len(sources) == 0 {
sources = append(sources, party.Source.Path)
}
return nonEmptySortedStrings(sources)
}
func artifactDefinitionSources(cfg *PipelineConfig, key string) []string { func artifactDefinitionSources(cfg *PipelineConfig, key string) []string {
return declarationDefinitionSources(cfg, return declarationDefinitionSources(cfg,
configkit.Keys("scriptorium", "artifacts", key), configkit.Keys("scriptorium", "artifacts", key),

View File

@@ -72,3 +72,11 @@ func newPipelineInspection(cfg *PipelineConfig) (*configkit.Result[effectivePipe
projection := projectEffectivePipeline(cfg) projection := projectEffectivePipeline(cfg)
return configkit.Load(configkit.NoSource(), configkit.Options[effectivePipelineProjection]{Definition: configkit.Definition[effectivePipelineProjection]{Defaults: func() effectivePipelineProjection { return projection }}}) return configkit.Load(configkit.NoSource(), configkit.Options[effectivePipelineProjection]{Definition: configkit.Definition[effectivePipelineProjection]{Defaults: func() effectivePipelineProjection { return projection }}})
} }
// DiffEffectivePipelines compares frozen final-domain snapshots.
func DiffEffectivePipelines(left, right *PipelineConfig) ([]configkit.Difference, error) {
if left == nil || right == nil || left.resolution == nil || right.resolution == nil {
return nil, fmt.Errorf("resolved pipelines are required")
}
return configkit.Diff(left.resolution.inspection, right.resolution.inspection)
}

View File

@@ -45,6 +45,48 @@ type EffectivePipelineSourceRecord struct {
Source string Source string
} }
// EmptyImportSelection describes a native optional selection that acquired no source.
type EmptyImportSelection struct {
Source string
Path string
Selector string
Line int
Column int
}
func emptyImportSelections[T any](result *configkit.Result[T]) []EmptyImportSelection {
if result == nil {
return nil
}
var selections []EmptyImportSelection
for _, listed := range result.Sources() {
source, ok := result.Source(listed.ID)
if !ok {
continue
}
name := source.Path
if name == "" {
name = source.Label
}
for _, item := range source.EmptyImportSelections {
selections = append(selections, EmptyImportSelection{Source: name, Path: item.Path.String(), Selector: string(item.Selector), Line: item.Location.Line, Column: item.Location.Column})
}
}
return selections
}
// EffectiveEmptyImports reports only optional selections that acquired nothing.
func EffectiveEmptyImports(pipeline *PipelineConfig, campaign *CampaignConfig) []EmptyImportSelection {
var result []EmptyImportSelection
if pipeline != nil && pipeline.resolution != nil {
result = append(result, emptyImportSelections(pipeline.resolution.authoring)...)
}
if campaign != nil && campaign.resolution != nil {
result = append(result, emptyImportSelections(campaign.resolution.campaign)...)
}
return result
}
// EffectivePipelineValueRecord identifies one normalized, secret-free // EffectivePipelineValueRecord identifies one normalized, secret-free
// effective configuration value. Values use deterministic compact JSON // effective configuration value. Values use deterministic compact JSON
// representations so command output can be compared without raw YAML layout. // representations so command output can be compared without raw YAML layout.
@@ -119,15 +161,19 @@ func EffectiveCampaignSources(campaignPath string, campaign *CampaignConfig, par
if campaign == nil { if campaign == nil {
return nil return nil
} }
campaignSource := normalizedProvenancePath(campaignPath) fields := []string{"campaign_id", "inputs.autocorrect_file", "inputs.glossary_file", "inputs.speakers_file", "inputs.party_file"}
records := []EffectivePipelineSourceRecord{
{Path: "campaign.campaign_id", Role: "campaign", Source: campaignSource},
{Path: "campaign.inputs.autocorrect_file", Role: "campaign", Source: campaignSource},
{Path: "campaign.inputs.glossary_file", Role: "campaign", Source: campaignSource},
{Path: "campaign.inputs.speakers_file", Role: "campaign", Source: campaignSource},
}
if strings.TrimSpace(campaign.Inputs.SpellCatalogFile) != "" { if strings.TrimSpace(campaign.Inputs.SpellCatalogFile) != "" {
records = append(records, EffectivePipelineSourceRecord{Path: "campaign.inputs.spell_catalog_file", Role: "campaign", Source: campaignSource}) fields = append(fields, "inputs.spell_catalog_file")
}
var records []EffectivePipelineSourceRecord
for _, field := range fields {
sources := campaignDefinitionSources(campaign, configkit.Keys(strings.Split(field, ".")...))
if len(sources) == 0 {
sources = []string{campaignPath}
}
for _, source := range sources {
records = append(records, EffectivePipelineSourceRecord{Path: "campaign." + field, Role: "campaign", Source: normalizedProvenancePath(source)})
}
} }
partySource := normalizedProvenancePath(party.Source.Path) partySource := normalizedProvenancePath(party.Source.Path)
records = append(records, records = append(records,
@@ -146,6 +192,43 @@ func EffectiveCampaignSources(campaignPath string, campaign *CampaignConfig, par
return records return records
} }
func campaignDefinitionSources(campaign *CampaignConfig, path configkit.Path) []string {
if campaign.resolution == nil || campaign.resolution.campaign == nil {
return nil
}
result := campaign.resolution.campaign
var ids []string
add := func(origin configkit.Origin) {
for _, location := range origin.Locations {
ids = append(ids, location.SourceID)
}
for _, step := range origin.Inheritance {
for _, location := range step.Locations {
ids = append(ids, location.SourceID)
}
}
}
if info, ok := result.Metadata().Lookup(path); ok {
add(info.Origin)
}
for _, change := range result.Metadata().History(path) {
if change.Origin.Layer == configkit.LayerMain || change.Origin.Layer == configkit.LayerOverlay {
add(change.Origin)
}
}
var sources []string
for _, id := range nonEmptySortedStrings(ids) {
if source, ok := result.Source(id); ok {
name := source.Path
if name == "" {
name = source.Label
}
sources = append(sources, name)
}
}
return nonEmptySortedStrings(sources)
}
// MarshalEffectivePipeline renders the validated, normalized pipeline as one // MarshalEffectivePipeline renders the validated, normalized pipeline as one
// deterministic YAML document. Composition declarations and runtime-only // deterministic YAML document. Composition declarations and runtime-only
// resolution data are excluded. Artifact family declarations are also omitted // resolution data are excluded. Artifact family declarations are also omitted
@@ -188,6 +271,14 @@ func effectivePipelineOwners(cfg *PipelineConfig) (map[string][]string, error) {
sources := []string{pipelineDefaultOwnershipSource} sources := []string{pipelineDefaultOwnershipSource}
if ok { if ok {
sources = ownershipSources(info.Origin, pathsByID) sources = ownershipSources(info.Origin, pathsByID)
if info.Origin.Layer == configkit.LayerResolution {
for _, change := range cfg.resolution.configkitMetadata.History(configkit.Keys(value.segments...)) {
if change.Origin.Layer == configkit.LayerMain || change.Origin.Layer == configkit.LayerOverlay {
sources = append(sources, ownershipSources(change.Origin, pathsByID)...)
}
}
sources = nonEmptySortedStrings(sources)
}
} }
owners[value.record.Path] = sources owners[value.record.Path] = sources
} }
@@ -247,8 +338,10 @@ func appendGeneratedArtifactSources(records []EffectivePipelineSourceRecord, pat
} }
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: role, Source: normalizedProvenanceSource(source)}) records = append(records, EffectivePipelineSourceRecord{Path: path, Role: role, Source: normalizedProvenanceSource(source)})
} }
if source := normalizedProvenancePath(party.Source.Path); source != "" { memberPath := strings.TrimPrefix(path, "scriptorium.artifacts.")
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: "party", Source: source}) memberKey, _, _ := strings.Cut(memberPath, ".")
for _, source := range partyCharacterSources(party, families.Members[memberKey].CharacterID) {
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: "party", Source: normalizedProvenancePath(source)})
} }
return records return records
} }

View File

@@ -22,6 +22,7 @@ const (
// CanonicalParty is the normalized domain value for narratio.party.v1. // CanonicalParty is the normalized domain value for narratio.party.v1.
type CanonicalParty struct { type CanonicalParty struct {
Characters []PartyCharacter Characters []PartyCharacter
authoring *configkit.Result[partyDocument]
} }
// PartyCharacter is one ordered character declaration from a canonical party. // PartyCharacter is one ordered character declaration from a canonical party.
@@ -244,7 +245,7 @@ func canonicalPartyFromResult(result *configkit.Result[partyDocument]) *Canonica
} }
return ordered[left].id < ordered[right].id return ordered[left].id < ordered[right].id
}) })
party := &CanonicalParty{Characters: make([]PartyCharacter, 0, len(ordered))} party := &CanonicalParty{Characters: make([]PartyCharacter, 0, len(ordered)), authoring: result}
for _, orderedCharacter := range ordered { for _, orderedCharacter := range ordered {
input := result.Config.Characters[orderedCharacter.id] input := result.Config.Characters[orderedCharacter.id]
classes := make([]PartyClass, len(input.Character.Classes)) classes := make([]PartyClass, len(input.Character.Classes))

View File

@@ -1,6 +1,7 @@
package config package config
import ( import (
"path/filepath"
"reflect" "reflect"
"strings" "strings"
"testing" "testing"
@@ -97,4 +98,13 @@ func TestImportedPartyExpandsFamilyIdentities(t *testing.T) {
t.Fatalf("missing family member %q", id) t.Fatalf("missing family member %q", id)
} }
} }
catalog, err := EffectiveArtifactCatalog(cfg.Pipeline, cfg.Party)
if err != nil {
t.Fatal(err)
}
for _, item := range catalog {
if strings.HasPrefix(item.Key, "character_meta_") && !strings.Contains(item.PartySource, filepath.Join(dir, "roster.yml")) {
t.Fatalf("catalog party source = %q", item.PartySource)
}
}
} }

View File

@@ -23,6 +23,7 @@ type pipelineResolutionMetadata struct {
configkitMetadata configkit.Metadata configkitMetadata configkit.Metadata
configkitSources []configkit.SourceInfo configkitSources []configkit.SourceInfo
inspection *configkit.Result[effectivePipelineProjection] inspection *configkit.Result[effectivePipelineProjection]
authoring *configkit.Result[PipelineConfig]
} }
type pipelineOverlaySelection struct { type pipelineOverlaySelection struct {
@@ -275,7 +276,7 @@ func validatePipelineConfigKit(cfg *PipelineConfig, validation *configkit.Valida
func pipelineMetadataFromConfigKit(result *configkit.Result[PipelineConfig], opts PipelineLoadOptions) *pipelineResolutionMetadata { func pipelineMetadataFromConfigKit(result *configkit.Result[PipelineConfig], opts PipelineLoadOptions) *pipelineResolutionMetadata {
sources := result.Sources() sources := result.Sources()
resolved := &pipelineResolutionMetadata{ resolved := &pipelineResolutionMetadata{
configkitMetadata: result.Metadata(), configkitSources: sources, configkitMetadata: result.Metadata(), configkitSources: sources, authoring: result,
} }
for index, source := range sources { for index, source := range sources {
path := source.Path path := source.Path
@@ -356,6 +357,11 @@ func pipelineSourcePaths(cfg *PipelineConfig) map[string]string {
return paths return paths
} }
for _, source := range cfg.resolution.configkitSources { for _, source := range cfg.resolution.configkitSources {
if cfg.resolution.authoring != nil {
if found, ok := cfg.resolution.authoring.Source(source.ID); ok {
source = found
}
}
path := source.Path path := source.Path
if path == "" { if path == "" {
path = source.Label path = source.Label