publisher

type AgentDialect ¶

type AgentDialect = projectstate.AgentDialect

AgentDialect preserves the project package's target-dialect compatibility name.

type ArtifactRole ¶

type ArtifactRole = outputplan.ArtifactRole

ArtifactRole preserves the project package's declaration-role compatibility name.

type Backup ¶

type Backup struct {
	Path  string // project-relative file that was overwritten
	Bak   string // project-relative backup copy (.awf-bak[.N])
	Index bool   // the file is the generated ADR/domain index (ownership-takeover note)
}

Backup records a foreign file preserved before sync overwrote its path.

type Capability ¶

type Capability = projectstate.Capability

Capability preserves the project package's target-capability compatibility name.

type Change ¶

type Change struct {
	Path  string
	Cause string
}

Change records a sync-written file whose rendered bytes differ from the prior lock's or whose required mode was corrected, with the cause the lock's hashes able to attribute: "template" (the upstream template source moved), "config" (the project's effective inputs - vars, sidecar, parts - moved), "template+config" (both), "internal" (hashes unmoved: a non-hashed input such as the binary's version stamp), "regenerated" (a generated index, which carries no hashes to attribute), or "added" (no prior entry). The provenance triage signal for reviewing a large sync diff - upstream churn vs the project's own inputs.

type ConfigKeyRow ¶

type ConfigKeyRow struct {
	Path, Type, Default, Description, Availability, Current string
}

ConfigKeyRow renders one config.yaml key or sidecar field in the config reference: a `configKeys` row always carries a resolved Current value, a `sidecarFields` row never does (there is no project-relative live value for a sidecar's own field), and the static catalog-only model leaves Current empty on every row.

type ConfigReference ¶

type ConfigReference struct {
	ConfigKeys    []ConfigKeyRow
	VarEntries    []VarRow
	SidecarFields []ConfigKeyRow
	DataKeys      []DataKeyRow
}

ConfigReference is the typed presentation model for `awf config`: the four dedicated collections PrintConfigReference renders, produced either with live project state (ConfigReferenceModel) or catalog-only (StaticConfigReference). It is the typed counterpart to the map[string]any shape configReferenceData still builds for the doc generator - a renamed field here is a compile error, never a silently empty render.

func StaticConfigReference() (ConfigReference, error)

type ContextPreparation ¶ added in v0.41.0

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

ContextPreparation is Publisher's focused semantic and declaration projection for ordinary context. It intentionally has no rendered output nodes or check projections.

func (p ContextPreparation) ADRs() adr.Corpus

func (p ContextPreparation) Declarations() []outputplan.Declaration

func (p ContextPreparation) Plans() []plan.Plan

func (p ContextPreparation) Topics() topic.Corpus

type DataKeyRow ¶

type DataKeyRow struct {
	Artifact, Key, Description, State string
}

DataKeyRow renders one per-artifact data key. State reports its observable catalog/project layering state.

type Effect ¶ added in v0.41.0

type Effect struct {
	Kind     string
	Path     string
	Recovery string
}

Effect is one committed filesystem fact and its stable retry or recovery action.

type InitAuthority ¶

type InitAuthority struct{ InitializedWithVersion string }

InitAuthority is the explicit provenance supplied only by first adoption.

type Layout ¶

type Layout struct {
	DocsDir    string
	ADRDir     string
	IndexMd    string
	PlansDir   string
	Docs       map[string]string // catalog name -> output path (inv: layout-docs-full-catalog)
	Singletons map[string]string // template key -> output path
	DomainsDir string
}

Layout is the fixed, awf-given docs layout in typed form for Go consumers. These paths are not configurable through the project tree. templateMap projects it into the .layout template namespace (templates read a map, not unexported struct fields) and into the per-file ConfigHash. The mandatory-singleton paths are not struct fields: they derive from the catalog doc collection in templateMap (ADR-0061).

type OutputDeclaration ¶

type OutputDeclaration struct {
	Path         string
	TemplateID   string
	Declarers    []string
	Inputs       []OutputInput
	Dependencies []string
}

OutputDeclaration records one deterministic declared output and its inputs.

type OutputInput ¶

type OutputInput struct {
	Path string
	Role ArtifactRole
}

OutputInput records one semantic input consumed by a declared output.

type OutputNode ¶

type OutputNode struct {
	Path                string
	Recipe              OutputRecipe
	Policy              OutputPolicy
	Declarers           []string
	DeclarerProjections []string
	DependsOn           []string
	ConsumedInputs      []OutputInput
	ObservedTemplateID  string
	// contains filtered or unexported fields
}

OutputNode is one path in the deterministic internal output plan.

type OutputPlan ¶

type OutputPlan struct {
	Nodes        []OutputNode
	Declarations []OutputDeclaration
}

OutputPlan is the single desired-output authority consumed by rendering, sync, manifest/prune, checks, and planned-output reporting.

type OutputPolicy ¶

type OutputPolicy = outputplan.Policy

OutputPolicy preserves the project package's output-policy compatibility name.

type OutputRecipe ¶

type OutputRecipe struct {
	TemplateID, TemplateHash, ConfigHash string
	Policy                               OutputPolicy
	Encoder                              AgentDialect
	Provenance                           string
}

OutputRecipe is the normalized, output-affecting declaration used for collision diagnostics and configuration hashes. Target identity is kept on OutputNode declarers rather than here, so compatible shared outputs coalesce.

type PartialError ¶ added in v0.41.0

type PartialError struct {
	Result Result
	Cause  error
}

PartialError reports a failed publication after one or more committed effects.

func (e *PartialError) Error() string

func (e *PartialError) Unwrap() error

type Preparation ¶

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

Preparation is one Publisher-owned derivation and its direct semantic projections for residual consumers.

func (p Preparation) ADRs() adr.Corpus

func (p Preparation) EffectiveSkills() map[string]bool

func (p Preparation) GeneratedOutput() generatedcheck.AdditionalInput

func (p Preparation) InitCollisions() ([]string, error)

func (p Preparation) Pitfalls() pitfall.Corpus

func (p Preparation) Plan() outputplan.Plan

func (p Preparation) Plans() []plan.Plan

func (p Preparation) PlansError() error

func (p Preparation) ResidentMarker(name string) (outputplan.Output, error)

func (p Preparation) Topics() topic.Corpus

func (p Preparation) Vocabulary() vocabularycheck.Input

type ProjectTreeReader ¶

type ProjectTreeReader = outputplan.TreeReader

ProjectTreeReader preserves the concise producer-internal name for the neutral operation tree reader.

func NewFilesystemReader(root string) ProjectTreeReader

type Publisher ¶

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

Publisher is the sole output-plan construction and rendering coordinator.

func New(state *projectstate.ProjectState, cfg *config.Config, read ProjectTreeReader, version string) *Publisher

func (p *Publisher) BuildConfigReference() (ConfigReference, error)

func (p *Publisher) InitCollisions() ([]string, error)

func (p *Publisher) Initialize(seed InitAuthority) (Result, error)

func (p *Publisher) InitializeLeased(ctx context.Context, lease *filesystem.Lease, seed InitAuthority) (Result, error)

func (p *Publisher) Plan() (outputplan.Plan, error)

func (p *Publisher) PreflightLocalDoc(doc config.LocalDoc) error

func (p *Publisher) Prepare() (Preparation, error)

func (p *Publisher) PrepareContext() (ContextPreparation, error)

func (p *Publisher) SyncLeased(ctx context.Context, lease *filesystem.Lease) (Result, error)

type RenderedFile ¶

type RenderedFile struct {
	Path         string
	Content      string
	TemplateID   string
	TemplateHash string
	ConfigHash   string
	// RegenChecked excludes this file from the frozen-OutputHash compare; its
	// drift is checked by regeneration instead (ADR-0100). Set on the generated
	// indexes and on any file carrying an in-place-editable section.
	RegenChecked bool
	// Policy declares all lifecycle checks for this path. It replaces
	// template-name and filename inference at plan consumers.
	Policy OutputPolicy
	// Declarer identifies the producer requesting this output.
	Declarer           string
	DeclarerProjection string
	Encoder            AgentDialect
	Provenance         render.CommentStyle

	// ConsumedInputs is observed at the render seam, independently of
	// buildOutputDeclarations: the context artifact report reads the observed
	// set, so a declaration omission or role mistake shows there rather than
	// being papered over by the declaration it was derived from.
	ConsumedInputs     []OutputInput
	ObservedTemplateID string
	// contains filtered or unexported fields
}

type Result ¶

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

Result records only mutations committed before the terminal outcome.

func (r Result) Backups() []Backup

func (r Result) Changes() []Change

func (r Result) Effects() []Effect

func (r Result) HasCommittedEffects() bool

func (r Result) Mutation() (presentation.Mutation, error)

func (r Result) PartialMutation() (presentation.Mutation, error)

func (r Result) Pruned() []string

type Target ¶

type Target = projectstate.Target

Target preserves the project package's resolved-target compatibility name.

type TargetOutput ¶

type TargetOutput = projectstate.TargetOutput

TargetOutput preserves the project package's target-output compatibility name.

type TargetOutputInput ¶

type TargetOutputInput = projectstate.TargetOutputInput

TargetOutputInput preserves the project package's target-input compatibility name.

type TargetOutputProducer ¶

type TargetOutputProducer = projectstate.TargetOutputProducer

TargetOutputProducer preserves the project package's producer compatibility name.

type VarRow ¶

type VarRow struct {
	Key, Description, Availability, State, Consumers string
}

VarRow renders one catalog var. State is the three-way live var state (set, empty, absent); it is empty in the static catalog-only model.