moonfeaturegate
MoonBit-native feature flag evaluation, targeting, rollout, and explanation toolkit.
feature-flags
rollout
configuration
moonbit
osc-2026
moon add wccerty/moonfeaturegate@0.1.3
Download zipAuthor
Version
0.1.3
License
Apache-2.0
Repository
Last updated
3 days ago
Downloads
17
README#MoonFeatureGate
MoonFeatureGate is a MoonBit-native feature flag and gradual rollout toolkit.
It evaluates flags locally, keeps rollout decisions deterministic, and returns
an explanation for every decision.
///|
test "README example evaluates a static flag" {
let provider = empty_provider().with_bool("demo", true)
let detail = evaluate_bool(provider, "demo", context("user-1"), default=false)
inspect(detail.value, content="true")
inspect(detail.reason, content="static")
}#FeatureProvider
#ParseError
#AuditIssue
pub(all) struct AuditIssue {
key : String
code : String
severity : AuditSeverity
message : String
} derive(Eq, Debug)#AuditReport
pub(all) struct AuditReport {
total_flags : Int
errors : Int
warnings : Int
infos : Int
issues : Array[AuditIssue]
} derive(Debug)#AuditReport::issue_count
#BatchResult
pub(all) struct BatchResult {
evaluations : Array[ValueEvaluation]
stats : BatchStats
reason_counts : Map[String, Int]
} derive(Debug)#BatchResult::reason_count
#BatchStats
#BenchmarkCase
A production-shaped fixture set used by the benchmark and acceptance
report. These cases represent the kinds of flags a service commonly owns:
release gates, experiments, regional policy, safety switches, and capacity
controls. They are deterministic and contain no customer data.
#BenchmarkReport
#BoolEvaluation
#CompatibilityLevel
Compatibility classification for configuration deployments. It provides a
reviewable answer to the common question: can this provider replace the
previous one without making existing flag lookups disappear?
#CompatibilityReport
pub(all) struct CompatibilityReport {
level : CompatibilityLevel
diff : ProviderDiff
message : String
} derive(Debug)#CompatibilityReport::is_safe
#CompatibilityReport::requires_replay
#CompatibilityReport::summary
#DecisionLedger
A small in-process decision ledger for tests, demos, and service health
dashboards. It stores aggregate counters only; no user identifiers are
retained, which keeps the default implementation privacy-friendly.
#DecisionLedger::merge
#DecisionLedger::reason_report
#DecisionLedger::record
#DecisionLedger::record_batch
#DecisionLedger::success_ratio
#DeploymentDecision
pub(all) struct DeploymentDecision {
allowed : Bool
health : ProviderHealth
compatibility : CompatibilityReport?
reason : String
} derive(Debug)Deployment decision that combines provider health with compatibility. This
is intentionally pure so release automation can use it in CI without
network access or process-global state.
#DeploymentDecision::health_status
#DeploymentDecision::is_release_ready
#DeploymentDecision::requires_manual_review
#DeploymentDecision::summary
#DoubleEvaluation
#EvalContext
#EvalContext::get_attr
#EvalContext::merge
#EvalContext::with_attr
#EvalContext::with_attrs
fn EvalContext::with_attrs(self : EvalContext, attributes : Array[(String, FlagValue)]) -> EvalContextAdds or replaces a batch of attributes while keeping the original context
immutable for callers that need to reuse it across requests.
#EvalContext::with_targeting_key
#EvaluationRequest
A typed request used by the batch evaluator. The default value also acts as
the expected type, so a configuration mistake remains visible instead of
being silently converted.
#EvaluationScenario
pub(all) struct EvaluationScenario {
name : String
requests : Array[EvaluationRequest]
contexts : Array[EvalContext]
} derive(Debug)A scenario is a deterministic set of contexts and typed requests. It makes
it possible to replay release decisions in CI, compare two configurations,
and publish benchmark evidence without connecting to a remote service.
#EvaluationScenario::run
fn[P : FeatureProvider] EvaluationScenario::run(self : EvaluationScenario, provider : P) -> ScenarioReport#ExposureAssessment
#ExposureAssessment::is_actionable
#ExposureAssessment::summary
#ExposureReport
pub(all) struct ExposureReport {
rows : Map[String, ExposureRow]
samples : Int
requests : Int
} derive(Debug)#ExposureReport::assess
fn ExposureReport::assess(self : ExposureReport, threshold : ExposureThreshold) -> ExposureAssessment#ExposureReport::compact_signature
A stable, compact signature is useful for comparing two canary samples in
logs without serializing every context or flag value.
#ExposureReport::coverage_percent
#ExposureReport::default_ratio
#ExposureReport::difference
#ExposureReport::empty_rows
#ExposureReport::evaluation_count
#ExposureReport::has_requested_key
#ExposureReport::healthy_for_release
#ExposureReport::inconsistent_rows
#ExposureReport::is_representative
#ExposureReport::merge
#ExposureReport::passes
#ExposureReport::reason_totals
#ExposureReport::recommendation
Produces a human-actionable next step instead of exposing raw counters to
an operator who has to interpret them during a release window.
#ExposureReport::rollout_match_ratio
#ExposureReport::rollout_rows
#ExposureReport::row
#ExposureReport::rows_for_prefix
#ExposureReport::rows_with_defaults
#ExposureReport::rows_with_target_misses
#ExposureReport::rows_with_type_mismatches
#ExposureReport::same_shape
#ExposureReport::targeting_miss_rate
#ExposureRequest
A request is the smallest unit of an exposure report. Keeping the default
value with the request makes reports useful for detecting accidental fallbacks
instead of only counting successful flag reads.
#ExposureRequest::default_kind
#ExposureRow
Aggregated observations for one flag over a stable set of request contexts.
The counters are mutually informative: matches + defaults equals the
number of samples, while the reason counters explain the default path.
#ExposureRow::reason_count
#ExposureThreshold
A threshold turns raw exposure data into a deployable gate. It is useful in
CI and can also be applied to a canary sample before a production switch.
#FlagDefinition
#FlagDefinition::validation_errors
Returns configuration defects without changing the provider. The JSON
parser performs the same checks while the builder API clamps rollout values;
this method is useful for provider inspection and diagnostics.
#FlagUsage
#FlagValue
#HealthStatus
Combined preflight result used before a configuration snapshot is
activated. Keeping audit, policy, and inventory together makes acceptance
output useful to both reviewers and operators.
#IntEvaluation
#PolicyReport
pub(all) struct PolicyReport {
provider_fingerprint : String
violations : Array[PolicyViolation]
} derive(Debug)#PolicyViolation
#Provider
impl FeatureProvider for Provider
#Provider::activate_if_compliant
#Provider::check_policy
#Provider::count_value_kind
#Provider::has_only_additions
#Provider::health_check
#Provider::keys_with_prefix
#Provider::overlay_if_safe
#Provider::same_configuration
#Provider::to_dsl
Returns the provider as the documented, line-oriented DSL. This is useful
for review diffs, fixtures, migration scripts, and small command-line
tools. The output is deterministic because flag keys are sorted.
#Provider::with_bool
#Provider::with_bool_rollout
#Provider::with_bool_target
#Provider::with_definition
Inserts a fully described definition for adapters and migration tools.
Builder helpers remain the preferred safe path for ordinary applications.
#Provider::with_double
#Provider::with_double_rollout
#Provider::with_double_target
#Provider::with_int
#Provider::with_int_rollout
#Provider::with_int_target
#Provider::with_string
#Provider::with_string_rollout
#Provider::with_string_target
#Provider::with_value
#Provider::with_value_rollout
#Provider::with_value_target
#ProviderDiff
#ProviderHealth
pub(all) struct ProviderHealth {
status : HealthStatus
audit : AuditReport
policy : PolicyReport
inventory : ProviderInventory
message : String
} derive(Debug)#ProviderInventory
#ProviderInventory::is_balanced
#ProviderPolicy
Deployment policy used by preflight checks. It lets a service enforce
conventions before activating a provider without changing evaluation rules.
#ProviderRegistry
pub(all) struct ProviderRegistry {
snapshots : Map[String, ProviderSnapshot]
active_name : String?
} derive(Debug)#ProviderRegistry::activate
#ProviderRegistry::active
#ProviderRegistry::active_provider
#ProviderRegistry::contains
#ProviderRegistry::get
#ProviderRegistry::register
#ProviderRegistry::remove
#ProviderSnapshot
An in-memory registry for safely switching between named configurations.
Applications can load providers from JSON or a custom source, audit them,
and activate a known-good snapshot without changing evaluator call sites.
#ProviderStats
#ReleaseApproval
#ReleaseChange
pub(all) struct ReleaseChange {
key : String
kind : String
risk : ReleaseRisk
message : String
} derive(Eq, Debug)A small, deterministic record for explaining why a release was classified
as risky. The message is intentionally short enough for CI annotations.
#ReleaseEnvironment
Environments describe the operational blast radius of a configuration
change. They are deliberately independent from a deployment platform so
the same plan can be reviewed locally, in CI, or by a service launcher.
#ReleaseEnvironment::maximum_risk
#ReleaseEnvironment::requires_approval
#ReleaseMetadata
pub(all) struct ReleaseMetadata {
owner : String
change_ticket : String
environment : ReleaseEnvironment
} derive(Eq, Debug)#ReleasePlan
pub(all) struct ReleasePlan {
metadata : ReleaseMetadata
next : Provider
previous : Provider?
health : ProviderHealth
compatibility : CompatibilityReport?
changes : Array[ReleaseChange]
risk : ReleaseRisk
approval : ReleaseApproval
allowed : Bool
} derive(Debug)#ReleasePlan::approval_steps
Returns operator-facing steps without performing them. This is suitable for
a change ticket or a deployment bot's dry-run output.
#ReleasePlan::approve
#ReleasePlan::environment
#ReleasePlan::has_breaking_change
#ReleasePlan::metadata_errors
#ReleasePlan::operator_notes
#ReleasePlan::provider_fingerprint
#ReleasePlan::reject
#ReleasePlan::requires_manual_approval
#ReleasePlan::rollback_fingerprint
#ReleaseRisk
#ReleaseRisk::at_least
#RolloutDistribution
#RolloutDistribution::summary
#RolloutDistribution::within_tolerance
fn RolloutDistribution::within_tolerance(self : RolloutDistribution, tolerance_basis_points : Double) -> Bool#ScenarioReport
pub(all) struct ScenarioReport {
name : String
contexts : Int
requests_per_context : Int
total : Int
matches : Int
defaults : Int
disabled : Int
target_misses : Int
rollout_misses : Int
type_mismatches : Int
ledger : DecisionLedger
} derive(Debug)#ScenarioReport::is_reproducible
#ScenarioReport::success_ratio
#StringEvaluation
#ValueEvaluation
#ValueEvaluation::uses_default
#analyze_exposure
fn analyze_exposure(provider : Provider, requests : Array[ExposureRequest], contexts : Array[EvalContext]) -> ExposureReportAnalyzes every request/context pair. The evaluator remains the single source
of truth, so the report cannot silently diverge from normal application
behavior.
#compare_providers
#deployment_check
fn deployment_check(previous : Provider?, next : Provider, policy : ProviderPolicy) -> DeploymentDecision#empty_context
Creates a context without a stable user key. This is useful for
application-wide flags that do not use percentage rollout.
#evaluate_batch
fn[P : FeatureProvider] evaluate_batch(provider : P, requests : Array[EvaluationRequest], ctx : EvalContext) -> BatchResult#evaluate_bool
fn[P : FeatureProvider] evaluate_bool(provider : P, flag_key : String, ctx : EvalContext, default~ : Bool) -> BoolEvaluation#evaluate_double
fn[P : FeatureProvider] evaluate_double(provider : P, flag_key : String, ctx : EvalContext, default~ : Double) -> DoubleEvaluation#evaluate_int
fn[P : FeatureProvider] evaluate_int(provider : P, flag_key : String, ctx : EvalContext, default~ : Int) -> IntEvaluation#evaluate_string
fn[P : FeatureProvider] evaluate_string(provider : P, flag_key : String, ctx : EvalContext, default~ : String) -> StringEvaluation#evaluate_value
fn[P : FeatureProvider] evaluate_value(provider : P, flag_key : String, ctx : EvalContext, default~ : FlagValue) -> ValueEvaluation#evaluate_with_ledger
fn[P : FeatureProvider] evaluate_with_ledger(provider : P, requests : Array[EvaluationRequest], ctx : EvalContext, ledger : DecisionLedger) -> BatchResult#exposure_request
#measure_rollout
fn measure_rollout(flag_key : String, targeting_keys : Array[String], percentage : Int) -> RolloutDistribution#plan_release
fn plan_release(previous : Provider?, next : Provider, environment~ : ReleaseEnvironment, policy~ : ProviderPolicy, owner~ : String, change_ticket~ : String) -> ReleasePlanBuilds a reviewable release plan. The function does not activate anything;
callers must explicitly approve the returned plan and perform activation.
#release_metadata
fn release_metadata(owner : String, change_ticket : String, environment : ReleaseEnvironment) -> ReleaseMetadata#rollout_buckets
#rollout_matches
fn rollout_matches(flag_key : String, targeting_key : String, percentage : Int) -> Bool#rollout_percentage_for
fn rollout_percentage_for(flag_key : String, targeting_key : String) -> Int#scenario
fn scenario(name : String, requests : Array[EvaluationRequest], contexts : Array[EvalContext]) -> EvaluationScenario#snapshot
Source Files
- MoonFeatureGate.mbt
- audit.mbt
- batch.mbt
- benchmark.mbt
- benchmark_cases.mbt
- compatibility.mbt
- context.mbt
- demo.mbt
- deployment.mbt
- eval.mbt
- exposure.mbt
- health.mbt
- interface.mbt
- json_provider.mbt
- ledger.mbt
- parser.mbt
- policy.mbt
- provider.mbt
- provider_tools.mbt
- registry.mbt
- release.mbt
- rollout.mbt
- scenario.mbt
- usage.mbt
- value.mbt
MoonBit-native feature flag evaluation, targeting, rollout, and explanation toolkit.
feature-flagsrolloutconfigurationmoonbitosc-2026
0.1.3
Apache-2.0
Updated 3 days ago
17 downloads