eyeling 1.21.9 → 1.22.0

package/examples/arcling/flandor/flandor.model.go

@@ -0,0 +1,630 @@
+package main
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"time"
+)
+
+type Data struct {
+	CaseName          string            `json:"caseName"`
+	Region            string            `json:"region"`
+	Question          string            `json:"question"`
+	Timestamps        Timestamps        `json:"timestamps"`
+	EvaluationContext EvaluationContext `json:"evaluationContext"`
+	Thresholds        Thresholds        `json:"thresholds"`
+	Signals           Signals           `json:"signals"`
+	Budget            Budget            `json:"budget"`
+	Packages          []Package         `json:"packages"`
+	InsightPolicy     InsightPolicy     `json:"insightPolicy"`
+	Integrity         Integrity         `json:"integrity"`
+}
+
+type Timestamps struct {
+	CreatedAt       string `json:"createdAt"`
+	ExpiresAt       string `json:"expiresAt"`
+	AuthorizedAt    string `json:"authorizedAt"`
+	DutyPerformedAt string `json:"dutyPerformedAt"`
+}
+
+type EvaluationContext struct {
+	ScopeDevice            string `json:"scopeDevice"`
+	ScopeEvent             string `json:"scopeEvent"`
+	Purpose                string `json:"purpose"`
+	ProhibitedReusePurpose string `json:"prohibitedReusePurpose"`
+}
+
+type Thresholds struct {
+	ExportOrdersIndexBelow       int     `json:"exportOrdersIndexBelow"`
+	TechnicalVacancyRatePctAbove float64 `json:"technicalVacancyRatePctAbove"`
+	GridCongestionHoursAbove     int     `json:"gridCongestionHoursAbove"`
+	ActiveNeedCountAtLeast       int     `json:"activeNeedCountAtLeast"`
+}
+
+type Cluster struct {
+	ID                string `json:"id"`
+	Name              string `json:"name"`
+	ExportOrdersIndex int    `json:"exportOrdersIndex"`
+	EnergyIntensity   int    `json:"energyIntensity"`
+}
+
+type LabourMarket struct {
+	TechnicalVacancyRatePct float64 `json:"technicalVacancyRatePct"`
+}
+
+type Grid struct {
+	CongestionHours         int `json:"congestionHours"`
+	RenewableCurtailmentMWh int `json:"renewableCurtailmentMWh"`
+}
+
+type Signals struct {
+	Clusters     []Cluster    `json:"clusters"`
+	LabourMarket LabourMarket `json:"labourMarket"`
+	Grid         Grid         `json:"grid"`
+}
+
+type Budget struct {
+	WindowName string `json:"windowName"`
+	MaxMEUR    int    `json:"maxMEUR"`
+}
+
+type Package struct {
+	ID                   string `json:"id"`
+	Name                 string `json:"name"`
+	CostMEUR             int    `json:"costMEUR"`
+	WorkerCoverage       int    `json:"workerCoverage"`
+	GridReliefMW         int    `json:"gridReliefMW"`
+	CoversExportWeakness bool   `json:"coversExportWeakness"`
+	CoversSkillsStrain   bool   `json:"coversSkillsStrain"`
+	CoversGridStress     bool   `json:"coversGridStress"`
+}
+
+type InsightPolicy struct {
+	ID               string `json:"id"`
+	Metric           string `json:"metric"`
+	Type             string `json:"type"`
+	SuggestionPolicy string `json:"suggestionPolicy"`
+	PolicyType       string `json:"policyType"`
+	PolicyProfile    string `json:"policyProfile"`
+}
+
+type Integrity struct {
+	HashAlgorithm    string `json:"hashAlgorithm"`
+	MacAlgorithm     string `json:"macAlgorithm"`
+	Secret           string `json:"secret"`
+	VerificationMode string `json:"verificationMode"`
+}
+
+type Insight struct {
+	CreatedAt        string `json:"createdAt"`
+	ExpiresAt        string `json:"expiresAt"`
+	ID               string `json:"id"`
+	Metric           string `json:"metric"`
+	Region           string `json:"region"`
+	ScopeDevice      string `json:"scopeDevice"`
+	ScopeEvent       string `json:"scopeEvent"`
+	SuggestionPolicy string `json:"suggestionPolicy"`
+	Threshold        int    `json:"threshold"`
+	Type             string `json:"type"`
+}
+
+type Constraint struct {
+	LeftOperand  string `json:"leftOperand"`
+	Operator     string `json:"operator"`
+	RightOperand string `json:"rightOperand"`
+}
+
+type Duty struct {
+	Action     string     `json:"action"`
+	Constraint Constraint `json:"constraint"`
+}
+
+type Permission struct {
+	Action     string     `json:"action"`
+	Constraint Constraint `json:"constraint"`
+	Target     string     `json:"target"`
+}
+
+type Prohibition struct {
+	Action     string     `json:"action"`
+	Constraint Constraint `json:"constraint"`
+	Target     string     `json:"target"`
+}
+
+type Policy struct {
+	Duty        Duty        `json:"duty"`
+	Permission  Permission  `json:"permission"`
+	Profile     string      `json:"profile"`
+	Prohibition Prohibition `json:"prohibition"`
+	Type        string      `json:"type"`
+}
+
+type Envelope struct {
+	Insight Insight `json:"insight"`
+	Policy  Policy  `json:"policy"`
+}
+
+type Derived struct {
+	ExportWeakness         bool     `json:"exportWeakness"`
+	SkillsStrain           bool     `json:"skillsStrain"`
+	GridStress             bool     `json:"gridStress"`
+	ActiveNeedCount        int      `json:"activeNeedCount"`
+	NeedsRetoolingPulse    bool     `json:"needsRetoolingPulse"`
+	EligiblePackageIDs     []string `json:"eligiblePackageIds"`
+	RecommendedPackageID   *string  `json:"recommendedPackageId"`
+	RecommendedPackageName *string  `json:"recommendedPackageName"`
+}
+
+type IntegrityResult struct {
+	CanonicalEnvelope  string `json:"canonicalEnvelope"`
+	PayloadHashSHA256  string `json:"payloadHashSHA256"`
+	EnvelopeHmacSHA256 string `json:"envelopeHmacSHA256"`
+	VerificationMode   string `json:"verificationMode"`
+}
+
+type Answer struct {
+	Name               string  `json:"name"`
+	Region             string  `json:"region"`
+	Metric             string  `json:"metric"`
+	ActiveNeedCount    int     `json:"activeNeedCount"`
+	Threshold          int     `json:"threshold"`
+	RecommendedPackage *string `json:"recommendedPackage"`
+	BudgetCapMEUR      int     `json:"budgetCapMEUR"`
+	PackageCostMEUR    *int    `json:"packageCostMEUR"`
+	PayloadHashSHA256  string  `json:"payloadHashSHA256"`
+	EnvelopeHmacSHA256 string  `json:"envelopeHmacSHA256"`
+}
+
+type Checks struct {
+	PayloadHashMatches              bool `json:"payloadHashMatches"`
+	SignatureVerifies               bool `json:"signatureVerifies"`
+	ThresholdReached                bool `json:"thresholdReached"`
+	ScopeComplete                   bool `json:"scopeComplete"`
+	MinimizationRespected           bool `json:"minimizationRespected"`
+	AuthorizationAllowed            bool `json:"authorizationAllowed"`
+	DutyTimely                      bool `json:"dutyTimely"`
+	SurveillanceReuseProhibited     bool `json:"surveillanceReuseProhibited"`
+	PackageWithinBudget             bool `json:"packageWithinBudget"`
+	PackageCoversAllActiveNeeds     bool `json:"packageCoversAllActiveNeeds"`
+	LowestCostEligiblePackageChosen bool `json:"lowestCostEligiblePackageChosen"`
+}
+
+type Result struct {
+	CaseName      string          `json:"caseName"`
+	Derived       Derived         `json:"derived"`
+	Envelope      Envelope        `json:"envelope"`
+	Integrity     IntegrityResult `json:"integrity"`
+	Answer        Answer          `json:"answer"`
+	ReasonWhy     []string        `json:"reasonWhy"`
+	Checks        Checks          `json:"checks"`
+	AllChecksPass bool            `json:"allChecksPass"`
+	ArcText       string          `json:"arcText"`
+}
+
+func assertTrue(condition bool, message string) error {
+	if !condition {
+		return errors.New(message)
+	}
+	return nil
+}
+
+func readJSON(path string) (Data, error) {
+	var data Data
+	b, err := os.ReadFile(path)
+	if err != nil {
+		return data, err
+	}
+	err = json.Unmarshal(b, &data)
+	return data, err
+}
+
+func parseTime(value string) time.Time {
+	t, err := time.Parse(time.RFC3339Nano, value)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+func stableStringify(value any) string {
+	switch v := value.(type) {
+	case nil:
+		return "null"
+	case map[string]any:
+		keys := make([]string, 0, len(v))
+		for key := range v {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		parts := make([]string, 0, len(keys))
+		for _, key := range keys {
+			parts = append(parts, fmt.Sprintf("%s:%s", stableStringify(key), stableStringify(v[key])))
+		}
+		return "{" + strings.Join(parts, ",") + "}"
+	case []any:
+		parts := make([]string, 0, len(v))
+		for _, item := range v {
+			parts = append(parts, stableStringify(item))
+		}
+		return "[" + strings.Join(parts, ",") + "]"
+	default:
+		b, _ := json.Marshal(v)
+		return string(b)
+	}
+}
+
+func canonicalValue(value any) any {
+	b, _ := json.Marshal(value)
+	var out any
+	_ = json.Unmarshal(b, &out)
+	return out
+}
+
+func validateInstance(data Data) error {
+	if err := assertTrue(data.CaseName != "", "caseName is required"); err != nil {
+		return err
+	}
+	if err := assertTrue(data.Region != "", "region is required"); err != nil {
+		return err
+	}
+	if err := assertTrue(len(data.Signals.Clusters) > 0, "signals.clusters is required"); err != nil {
+		return err
+	}
+	if err := assertTrue(len(data.Packages) > 0, "packages is required"); err != nil {
+		return err
+	}
+	return nil
+}
+
+func countTrue(values ...bool) int {
+	total := 0
+	for _, value := range values {
+		if value {
+			total++
+		}
+	}
+	return total
+}
+
+func clauseR1ExportWeakness(data Data) bool {
+	for _, cluster := range data.Signals.Clusters {
+		if cluster.ExportOrdersIndex < data.Thresholds.ExportOrdersIndexBelow {
+			return true
+		}
+	}
+	return false
+}
+
+func clauseR2SkillsStrain(data Data) bool {
+	return data.Signals.LabourMarket.TechnicalVacancyRatePct > data.Thresholds.TechnicalVacancyRatePctAbove
+}
+
+func clauseR3GridStress(data Data) bool {
+	return data.Signals.Grid.CongestionHours > data.Thresholds.GridCongestionHoursAbove
+}
+
+func clauseR4ActiveNeedCount(exportWeakness, skillsStrain, gridStress bool) int {
+	return countTrue(exportWeakness, skillsStrain, gridStress)
+}
+
+func clauseR5NeedsRetoolingPulse(data Data, activeNeedCount int) bool {
+	return activeNeedCount >= data.Thresholds.ActiveNeedCountAtLeast
+}
+
+func deriveInsight(data Data) Insight {
+	return Insight{
+		CreatedAt:        data.Timestamps.CreatedAt,
+		ExpiresAt:        data.Timestamps.ExpiresAt,
+		ID:               data.InsightPolicy.ID,
+		Metric:           data.InsightPolicy.Metric,
+		Region:           data.Region,
+		ScopeDevice:      data.EvaluationContext.ScopeDevice,
+		ScopeEvent:       data.EvaluationContext.ScopeEvent,
+		SuggestionPolicy: data.InsightPolicy.SuggestionPolicy,
+		Threshold:        data.Thresholds.ActiveNeedCountAtLeast,
+		Type:             data.InsightPolicy.Type,
+	}
+}
+
+func derivePolicy(data Data) Policy {
+	return Policy{
+		Duty: Duty{
+			Action: "odrl:delete",
+			Constraint: Constraint{
+				LeftOperand:  "odrl:dateTime",
+				Operator:     "odrl:eq",
+				RightOperand: data.Timestamps.ExpiresAt,
+			},
+		},
+		Permission: Permission{
+			Action: "odrl:use",
+			Constraint: Constraint{
+				LeftOperand:  "odrl:purpose",
+				Operator:     "odrl:eq",
+				RightOperand: data.EvaluationContext.Purpose,
+			},
+			Target: data.InsightPolicy.ID,
+		},
+		Profile: data.InsightPolicy.PolicyProfile,
+		Prohibition: Prohibition{
+			Action: "odrl:distribute",
+			Constraint: Constraint{
+				LeftOperand:  "odrl:purpose",
+				Operator:     "odrl:eq",
+				RightOperand: data.EvaluationContext.ProhibitedReusePurpose,
+			},
+			Target: data.InsightPolicy.ID,
+		},
+		Type: data.InsightPolicy.PolicyType,
+	}
+}
+
+func packageCoversAllActiveNeeds(pkg Package, exportWeakness, skillsStrain, gridStress bool) bool {
+	return (!exportWeakness || pkg.CoversExportWeakness) &&
+		(!skillsStrain || pkg.CoversSkillsStrain) &&
+		(!gridStress || pkg.CoversGridStress)
+}
+
+func clauseS1EligiblePackages(data Data, exportWeakness, skillsStrain, gridStress bool) []Package {
+	eligible := make([]Package, 0)
+	for _, pkg := range data.Packages {
+		if pkg.CostMEUR <= data.Budget.MaxMEUR && packageCoversAllActiveNeeds(pkg, exportWeakness, skillsStrain, gridStress) {
+			eligible = append(eligible, pkg)
+		}
+	}
+	sort.Slice(eligible, func(i, j int) bool { return eligible[i].CostMEUR < eligible[j].CostMEUR })
+	return eligible
+}
+
+func clauseS2RecommendedPackage(data Data, exportWeakness, skillsStrain, gridStress bool) ([]Package, *Package) {
+	eligible := clauseS1EligiblePackages(data, exportWeakness, skillsStrain, gridStress)
+	if len(eligible) == 0 {
+		return eligible, nil
+	}
+	recommended := eligible[0]
+	return eligible, &recommended
+}
+
+func clauseG1AuthorizedUse(data Data) bool {
+	return data.EvaluationContext.Purpose == "regional_stabilization" && !parseTime(data.Timestamps.AuthorizedAt).After(parseTime(data.Timestamps.ExpiresAt))
+}
+
+func clauseG2SurveillanceReuseProhibited(data Data) bool {
+	return data.EvaluationContext.ProhibitedReusePurpose == "firm_surveillance"
+}
+
+func clauseG3DutyTimely(data Data) bool {
+	return !parseTime(data.Timestamps.DutyPerformedAt).After(parseTime(data.Timestamps.ExpiresAt))
+}
+
+func clauseM1CanonicalEnvelope(data Data) (Envelope, string) {
+	envelope := Envelope{Insight: deriveInsight(data), Policy: derivePolicy(data)}
+	return envelope, stableStringify(canonicalValue(envelope))
+}
+
+func sha256Hex(text string) string {
+	sum := sha256.Sum256([]byte(text))
+	return hex.EncodeToString(sum[:])
+}
+
+func hmacSHA256Hex(secret, text string) string {
+	mac := hmac.New(sha256.New, []byte(secret))
+	_, _ = mac.Write([]byte(text))
+	return hex.EncodeToString(mac.Sum(nil))
+}
+
+func clauseM4MinimizationRespected(insight Insight) bool {
+	b, _ := json.Marshal(insight)
+	s := strings.ToLower(string(b))
+	return !strings.Contains(s, "salary") && !strings.Contains(s, "payroll") && !strings.Contains(s, "invoice") && !strings.Contains(s, "medical") && !strings.Contains(s, "firmname")
+}
+
+func clauseM5ScopeComplete(insight Insight) bool {
+	return insight.ScopeDevice != "" && insight.ScopeEvent != "" && insight.ExpiresAt != ""
+}
+
+func yesNo(value bool) string {
+	if value {
+		return "PASS"
+	}
+	return "FAIL"
+}
+
+func evaluate(data Data) (Result, error) {
+	if err := validateInstance(data); err != nil {
+		return Result{}, err
+	}
+
+	exportWeakness := clauseR1ExportWeakness(data)
+	skillsStrain := clauseR2SkillsStrain(data)
+	gridStress := clauseR3GridStress(data)
+	activeNeedCount := clauseR4ActiveNeedCount(exportWeakness, skillsStrain, gridStress)
+	needsRetoolingPulse := clauseR5NeedsRetoolingPulse(data, activeNeedCount)
+
+	envelope, canonicalEnvelope := clauseM1CanonicalEnvelope(data)
+	payloadHashSHA256 := sha256Hex(canonicalEnvelope)
+	envelopeHmacSHA256 := hmacSHA256Hex(data.Integrity.Secret, canonicalEnvelope)
+
+	eligible, recommended := clauseS2RecommendedPackage(data, exportWeakness, skillsStrain, gridStress)
+	recommendedID := (*string)(nil)
+	recommendedName := (*string)(nil)
+	packageCostMEUR := (*int)(nil)
+	if recommended != nil {
+		recommendedID = &recommended.ID
+		recommendedName = &recommended.Name
+		packageCostMEUR = &recommended.CostMEUR
+	}
+
+	checks := Checks{
+		PayloadHashMatches:              payloadHashSHA256 == sha256Hex(canonicalEnvelope),
+		SignatureVerifies:               data.Integrity.VerificationMode == "trustedPrecomputedInput" && envelopeHmacSHA256 == hmacSHA256Hex(data.Integrity.Secret, canonicalEnvelope),
+		ThresholdReached:                needsRetoolingPulse,
+		ScopeComplete:                   clauseM5ScopeComplete(envelope.Insight),
+		MinimizationRespected:           clauseM4MinimizationRespected(envelope.Insight),
+		AuthorizationAllowed:            clauseG1AuthorizedUse(data),
+		DutyTimely:                      clauseG3DutyTimely(data),
+		SurveillanceReuseProhibited:     clauseG2SurveillanceReuseProhibited(data),
+		PackageWithinBudget:             recommended != nil && recommended.CostMEUR <= data.Budget.MaxMEUR,
+		PackageCoversAllActiveNeeds:     recommended != nil && packageCoversAllActiveNeeds(*recommended, exportWeakness, skillsStrain, gridStress),
+		LowestCostEligiblePackageChosen: recommended != nil && recommended.ID == eligible[0].ID,
+	}
+
+	clusterBits := make([]string, 0, len(data.Signals.Clusters))
+	for _, cluster := range data.Signals.Clusters {
+		clusterBits = append(clusterBits, fmt.Sprintf("%s=%d", cluster.Name, cluster.ExportOrdersIndex))
+	}
+
+	reasonWhy := []string{
+		fmt.Sprintf("ExportWeakness holds because at least one cluster has exportOrdersIndex < %d (%s).", data.Thresholds.ExportOrdersIndexBelow, strings.Join(clusterBits, ", ")),
+		fmt.Sprintf("SkillsStrain holds because the technical vacancy rate is %g%% and the threshold is > %g%%.", data.Signals.LabourMarket.TechnicalVacancyRatePct, data.Thresholds.TechnicalVacancyRatePctAbove),
+		fmt.Sprintf("GridStress holds because congestion hours = %d and the threshold is > %d.", data.Signals.Grid.CongestionHours, data.Thresholds.GridCongestionHoursAbove),
+		"The recommendation rule selects the least-cost package that covers every active need and remains within budget.",
+		func() string {
+			if recommended != nil {
+				return fmt.Sprintf("The selected package is \"%s\" with cost €%dM, workerCoverage=%d, gridReliefMW=%d.", recommended.Name, recommended.CostMEUR, recommended.WorkerCoverage, recommended.GridReliefMW)
+			}
+			return "No eligible package exists within budget."
+		}(),
+		fmt.Sprintf("Use is permitted only for purpose \"%s\" and expires at %s.", data.EvaluationContext.Purpose, data.Timestamps.ExpiresAt),
+	}
+
+	answer := Answer{
+		Name:               data.CaseName,
+		Region:             data.Region,
+		Metric:             data.InsightPolicy.Metric,
+		ActiveNeedCount:    activeNeedCount,
+		Threshold:          data.Thresholds.ActiveNeedCountAtLeast,
+		RecommendedPackage: recommendedName,
+		BudgetCapMEUR:      data.Budget.MaxMEUR,
+		PackageCostMEUR:    packageCostMEUR,
+		PayloadHashSHA256:  payloadHashSHA256,
+		EnvelopeHmacSHA256: envelopeHmacSHA256,
+	}
+
+	arcLines := []string{
+		"=== Answer ===",
+		fmt.Sprintf("Name: %s", answer.Name),
+		fmt.Sprintf("Region: %s", answer.Region),
+		fmt.Sprintf("Metric: %s", answer.Metric),
+		fmt.Sprintf("Active need count: %d/%d", answer.ActiveNeedCount, answer.Threshold),
+		fmt.Sprintf("Recommended package: %s", derefString(answer.RecommendedPackage)),
+		fmt.Sprintf("Budget cap: €%dM", answer.BudgetCapMEUR),
+		fmt.Sprintf("Package cost: €%sM", derefIntString(answer.PackageCostMEUR)),
+		fmt.Sprintf("Payload SHA-256: %s", answer.PayloadHashSHA256),
+		fmt.Sprintf("Envelope HMAC-SHA-256: %s", answer.EnvelopeHmacSHA256),
+		"",
+		"=== Reason Why ===",
+	}
+	arcLines = append(arcLines, reasonWhy...)
+	arcLines = append(arcLines, "", "=== Check ===")
+	checkOrder := []struct {
+		name string
+		ok   bool
+	}{
+		{"payloadHashMatches", checks.PayloadHashMatches},
+		{"signatureVerifies", checks.SignatureVerifies},
+		{"thresholdReached", checks.ThresholdReached},
+		{"scopeComplete", checks.ScopeComplete},
+		{"minimizationRespected", checks.MinimizationRespected},
+		{"authorizationAllowed", checks.AuthorizationAllowed},
+		{"dutyTimely", checks.DutyTimely},
+		{"surveillanceReuseProhibited", checks.SurveillanceReuseProhibited},
+		{"packageWithinBudget", checks.PackageWithinBudget},
+		{"packageCoversAllActiveNeeds", checks.PackageCoversAllActiveNeeds},
+		{"lowestCostEligiblePackageChosen", checks.LowestCostEligiblePackageChosen},
+	}
+	for _, item := range checkOrder {
+		arcLines = append(arcLines, fmt.Sprintf("- %s: %s", yesNo(item.ok), item.name))
+	}
+
+	allChecksPass := checks.PayloadHashMatches && checks.SignatureVerifies && checks.ThresholdReached && checks.ScopeComplete && checks.MinimizationRespected && checks.AuthorizationAllowed && checks.DutyTimely && checks.SurveillanceReuseProhibited && checks.PackageWithinBudget && checks.PackageCoversAllActiveNeeds && checks.LowestCostEligiblePackageChosen
+
+	return Result{
+		CaseName: data.CaseName,
+		Derived: Derived{
+			ExportWeakness:      exportWeakness,
+			SkillsStrain:        skillsStrain,
+			GridStress:          gridStress,
+			ActiveNeedCount:     activeNeedCount,
+			NeedsRetoolingPulse: needsRetoolingPulse,
+			EligiblePackageIDs: func() []string {
+				ids := make([]string, 0, len(eligible))
+				for _, pkg := range eligible {
+					ids = append(ids, pkg.ID)
+				}
+				return ids
+			}(),
+			RecommendedPackageID:   recommendedID,
+			RecommendedPackageName: recommendedName,
+		},
+		Envelope: envelope,
+		Integrity: IntegrityResult{
+			CanonicalEnvelope:  canonicalEnvelope,
+			PayloadHashSHA256:  payloadHashSHA256,
+			EnvelopeHmacSHA256: envelopeHmacSHA256,
+			VerificationMode:   data.Integrity.VerificationMode,
+		},
+		Answer:        answer,
+		ReasonWhy:     reasonWhy,
+		Checks:        checks,
+		AllChecksPass: allChecksPass,
+		ArcText:       strings.Join(arcLines, "\n"),
+	}, nil
+}
+
+func derefString(value *string) string {
+	if value == nil {
+		return "<nil>"
+	}
+	return *value
+}
+
+func derefIntString(value *int) string {
+	if value == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("%d", *value)
+}
+
+func main() {
+	inputPath := "flandor.data.json"
+	jsonMode := false
+	for _, arg := range os.Args[1:] {
+		if arg == "--json" {
+			jsonMode = true
+		} else if !strings.HasPrefix(arg, "--") {
+			inputPath = arg
+		}
+	}
+
+	data, err := readJSON(inputPath)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	result, err := evaluate(data)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	if jsonMode {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		_ = enc.Encode(result)
+	} else {
+		fmt.Println(result.ArcText)
+	}
+
+	if !result.AllChecksPass {
+		os.Exit(1)
+	}
+}

package/examples/arcling/flandor/flandor.spec.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-This document is the **normative specification** for the Flandor case. The file `flandor.model.mjs` is the **reference ECMAScript implementation** of these clauses. The file `flandor.data.json` is the **instance** evaluated in this bundle. The file `flandor.expected.json` is the **conformance vector** for that instance.
+This document is the **normative specification** for the Flandor case. The file `flandor.model.go` is the **reference Go implementation** of these clauses. The file `flandor.data.json` is the **instance** evaluated in this bundle. The file `flandor.expected.json` is the **conformance vector** for that instance.
 
 ## Insight Economy context
 
@@ -15,7 +15,6 @@ The product being traded is therefore not raw data, and not even a general forec
 - “iff” means “if and only if”.
 - A clause identifier such as `R1` or `M3` is normative.
 - A conforming implementation may be written in any language, but it shall produce the same derived values and pass/fail outcomes for the supplied instance.
-- The reference implementation uses ECMAScript because you preferred an international-standard JS language.
 
 ## Vocabulary