tcq

type ClaimResult ¶

type ClaimResult struct {
	ObligationID       string
	ClaimID            string
	AnchorProfile      string
	AssociationKind    string
	AssociationState   string
	HygieneState       string
	ReportState        string
	TestUnitID         string
	ExecutionKeySha256 string
	RowIDs             []string
	Reasons            []string
	Relation           string
	// AuthorityClass is CALLER_REPORTED for every edge, including abstentions
	// (TCQ-V0-006). It is carried rather than assumed so no future producer can
	// silently upgrade it.
	AuthorityClass string
}

ClaimResult is one selected claim edge, in the shape of the reference vector at docs/specs/test-claim-qualification-v0.md:391. Empty string stands for the document's `null` in the nullable fields.

type Error ¶

type Error struct {
	Code string
}

Error is one bounded operational failure. Per TCQ-V0-042 an operational error emits no partial artifact and no unverified path, OID, digest, selector, count, command argument, XML value, or derived identity — so the code alone is the payload and Message never carries input-derived text.

func (err *Error) Error() string

type Repository ¶

type Repository interface {
	// Blob returns the bytes of one target-tree blob by OID.
	Blob(oid string) ([]byte, error)
	// TreeEntry resolves one normalized repository-relative path at revision.
	// A missing object is (TreeEntry{}, nil), never an error; an error is a
	// failed lookup, which TCQ returns as-is (TCQ-V0-028).
	TreeEntry(revision, path string) (TreeEntry, error)
}

Repository is that inherited boundary. Both methods read the verified target tree only; sibling repositories, alternates, implicit fetch, and additional-repository discovery are forbidden and must be refused by the implementation, not by TCQ.

type Request ¶

type Request struct {
	CEM          []byte
	OCM          []byte
	ExpectedBase string
	Target       string

	// The dynamic tuple is all-or-none (TCQ-V0-033). Any other combination is
	// `invalid-tcq-input`.
	Command     []byte
	Observation []byte
	Report      []byte

	// Expected optionally verifies a cached result byte-for-byte (TCQ-V0-043).
	Expected []byte
}

Request is one TCQ invocation. Every artifact is caller-supplied immutable bytes (TCQ-V0-044); TCQ opens no raw-artifact filesystem path.

type Resolved ¶

type Resolved struct {
	BaseRevision   string
	TargetRevision string
}

Resolved carries the two OIDs the shared CEM/OCM verifier resolved from the independent invocation inputs. TCQ-V0-036 binds these, never values learned from an artifact.

type Result ¶

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

Result and ClaimResult are the producer side of the frozen seam declared in internal/frontier/upstream.go. A shim converts Result.ID/Result.Claims into frontier.TCQResult/TCQClaimResult field for field; this package deliberately does not import frontier, which consumes it. Frontier's TCQRequest carries no CEM bytes, so a shim must supply the canonical `cem/0.2` artifact the OCM binds — TCQ-V0-001 requires it and TCQ-V0-002 refuses `cem/0.1`.

Result is one `tcq/0` document. It is a recomputable local cache, never an authority token or execution record (TCQ-V0-043): Raw is the canonical bytes the identity commits to, and every consumer must recompute rather than trust.

func Evaluate(repository Repository, verifier UpstreamVerifier, request Request) (Result, error)

func (result Result) Claims() []ClaimResult

func (result Result) ID() string

func (result Result) Raw() []byte

type TreeEntry ¶

type TreeEntry struct {
	Mode  string
	Type  string
	Found bool
}

TreeEntry is one resolved target-tree object. TCQ never opens a worktree path: TCQ-V0-001 confines every source read to the inherited bounded, sanitized, no-fetch Git boundary.

type UpstreamVerifier ¶

type UpstreamVerifier interface {
	VerifyOCM(cemRaw, ocmRaw []byte, expectedBase, target string) (Resolved, error)
}

UpstreamVerifier is the current OCM verifier, which in turn invokes the shared CEM 0.2 canonical verifier. TCQ-V0-001 requires the same bounded raw byte copies and both revision inputs to pass through it, and TCQ-V0-042 forbids reordering any validation internal to it — hence a seam rather than a reimplementation.