🥮 mooncakes.io
README

vectie/moonlib/pipeline does not have a README file

#
ArtifactRef

source
pub(all) struct ArtifactRef {
  artifact_id : String
  producer : String
  digest : String
  uri : String
  authority : String
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
ArtifactRef::quality_issues

source
fn ArtifactRef::quality_issues(self : ArtifactRef) -> Array[String]

#
AuthorityClass

source
pub(all) enum AuthorityClass {
  Observe
  CognitiveMaintenance
  SandboxExecution
  WorkspaceMutation
  ExternalEffect
  PhysicalEffect
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
AuthorityClass::allows

source
fn AuthorityClass::allows(self : AuthorityClass, requested : AuthorityClass) -> Bool

#
AuthorityClass::id

source
fn AuthorityClass::id(self : AuthorityClass) -> String

#
AuthorityClass::requires_explicit_human

source
fn AuthorityClass::requires_explicit_human(self : AuthorityClass) -> Bool

#
AuthorityGrant

source
pub(all) struct AuthorityGrant {
  authority_id : String
  actor_id : String
  class : AuthorityClass
  scope : Array[String]
  granted_by : String
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
AuthorityGrant::quality_issues

source
fn AuthorityGrant::quality_issues(self : AuthorityGrant) -> Array[String]

#
AutonomyBudget

source
pub(all) struct AutonomyBudget {
  model_tokens : Int
  tool_calls : Int
  storage_bytes : Int
  attempts : Int
  concurrency : Int
} derive(Eq, ToJson, 
Debug)

#
AutonomyBudget::quality_issues

source
fn AutonomyBudget::quality_issues(self : AutonomyBudget) -> Array[String]

#
AutonomyBudgetBalance

source
pub(all) struct AutonomyBudgetBalance {
  model_tokens : Int
  tool_calls : Int
  storage_bytes : Int
  attempts : Int
  concurrency : Int
} derive(Eq, ToJson, 
Debug)

#
AutonomyBudgetUsage

source
pub(all) struct AutonomyBudgetUsage {
  model_tokens : Int
  tool_calls : Int
  storage_bytes : Int
  attempts : Int
  concurrency : Int
} derive(Eq, ToJson, 
Debug)

#
AutonomyBudgetUsage::quality_issues

source
fn AutonomyBudgetUsage::quality_issues(self : AutonomyBudgetUsage) -> Array[String]

#
AutonomyDecision

source
pub(all) struct AutonomyDecision {
  contract_id : String
  decision_id : String
  envelope_id : String
  event_id : String
  accepted : Bool
  findings : Array[String]
  remaining_budget : AutonomyBudgetBalance
  checked_at : String
} derive(Eq, ToJson, 
Debug)

#
AutonomyEnvelope

source
pub(all) struct AutonomyEnvelope {
  contract_id : String
  envelope_id : String
  mode : String
  goal_ref : String
  workspace_root : String
  grants : Array[AutonomyGrant]
  budget : AutonomyBudget
  external_effects_allowed : Bool
  physical_effects_allowed : Bool
  granted_by : String
  source_digest : String
  recorded_at : String
  expires_at : String
  revoked : Bool
} derive(Eq, ToJson, 
Debug)

#
AutonomyEnvelope::quality_issues

source
fn AutonomyEnvelope::quality_issues(self : AutonomyEnvelope) -> Array[String]

#
AutonomyEventRequest

source
pub(all) struct AutonomyEventRequest {
  contract_id : String
  event_id : String
  run_id : String
  product_id : String
  operation : String
  requested_authority : AuthorityClass
  claim : ClaimClass
  artifact_paths : Array[String]
  external_destination : String
  budget_request : AutonomyBudgetUsage
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
AutonomyGrant

source
pub(all) struct AutonomyGrant {
  product_id : String
  operations : Array[String]
  authority_ceiling : AuthorityClass
  claim_ceiling : ClaimClass
  artifact_prefixes : Array[String]
} derive(Eq, ToJson, 
Debug)

#
AutonomyGrant::quality_issues

source
fn AutonomyGrant::quality_issues(self : AutonomyGrant) -> Array[String]

#
BeliefUpdate

source
pub(all) struct BeliefUpdate {
  update_id : String
  book_id : String
  belief_id : String
  statement : String
  change : String
  evidence_refs : Array[String]
  confidence : Double
  affected_refs : Array[String]
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
BeliefUpdate::quality_issues

source
fn BeliefUpdate::quality_issues(self : BeliefUpdate) -> Array[String]

#
BookkeeperReflection

source
pub(all) struct BookkeeperReflection {
  reflection_id : String
  book_id : String
  trigger : String
  observations : Array[String]
  gaps : Array[KnowledgeGap]
  belief_updates : Array[BeliefUpdate]
  proposed_actions : Array[ExecutableDeclaration]
  learned_procedures : Array[LearnedProcedure]
  confidence : Double
  uncertainty : Array[String]
  requested_authority : AuthorityClass
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
BookkeeperReflection::quality_issues

source
fn BookkeeperReflection::quality_issues(self : BookkeeperReflection) -> Array[String]

#
BrowserActionReceipt

source
pub(all) struct BrowserActionReceipt {
  contract_id : String
  receipt_id : String
  session_id : String
  action_id : String
  actor_kind : BrowserActor
  actor_id : String
  operation : BrowserOperation
  semantic_target : String
  redacted_arguments : Array[String]
  expected_observation : String
  authority_decision_ref : String
  before_digest : String
  after_digest : String
  outcome : String
  observations : Array[String]
  evidence_refs : Array[String]
  completed_at : String
} derive(Eq, ToJson, 
Debug)

#
BrowserActionReceipt::quality_issues

source
fn BrowserActionReceipt::quality_issues(self : BrowserActionReceipt) -> Array[String]

#
BrowserActor

source
pub(all) enum BrowserActor {
  HumanUser
  Agent
  Replay
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
BrowserActor::id

source
fn BrowserActor::id(self : BrowserActor) -> String

#
BrowserOperation

source
pub(all) enum BrowserOperation {
  RenderLocal
  InspectPage
  InteractLocal
  SaveWorkspace
  NavigateExternal
  UploadExternal
  DownloadExternal
  SubmitExternal
  ControlPhysicalDevice
} derive(Compare, Eq, Hash, ToJson, 
Debug)

A browser operation is typed before MoonGate evaluates its authority.

#
BrowserOperation::id

source
fn BrowserOperation::id(self : BrowserOperation) -> String

#
BrowserOperation::required_authority

source
fn BrowserOperation::required_authority(self : BrowserOperation) -> AuthorityClass

#
BrowserSessionScope

source
pub(all) struct BrowserSessionScope {
  contract_id : String
  session_id : String
  book_id : String
  book_revision : String
  code_revision : String
  run_id : String
  artifact_id : String
  authority_envelope_id : String
  origin_class : String
  network_policy : String
  allowed_origins : Array[String]
  allowed_operations : Array[BrowserOperation]
  upload_artifact_refs : Array[String]
  download_root : String
  storage_lifetime : String
  capability_digest : String
  expires_at : String
} derive(Eq, ToJson, 
Debug)

#
BrowserSessionScope::quality_issues

source
fn BrowserSessionScope::quality_issues(self : BrowserSessionScope) -> Array[String]

#
ClaimClass

source
pub(all) enum ClaimClass {
  Observation
  ResearchEvidence
  ExecutionResult
  AcceptedKnowledge
  DigitalArtifact
  SimulationEvidence
  ScenarioQualified
  CalibratedDigitalTwin
  HardwareInLoopQualified
  EngineeringUnitQualified
  PhysicalReadiness
  PhysicalEffectClaim
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
ClaimClass::allows

source
fn ClaimClass::allows(self : ClaimClass, requested : ClaimClass) -> Bool

#
ClaimClass::id

source
fn ClaimClass::id(self : ClaimClass) -> String

#
CognitionGapKind

source
pub(all) enum CognitionGapKind {
  InformationGap
  CognitionGap
  ExecutionGap
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
CognitionGapKind::id

source
fn CognitionGapKind::id(self : CognitionGapKind) -> String

#
ConformanceFinding

source
pub(all) struct ConformanceFinding {
  code : String
  path : String
  message : String
  severity : String
} derive(Eq, ToJson, 
Debug)

#
ConformanceSubject

source
pub(all) struct ConformanceSubject {
  subject_id : String
  product_id : String
  operation : String
  requested_authority : AuthorityClass
  input_contracts : Array[String]
  output_contracts : Array[String]
  claim : ClaimClass
  criteria : Array[CriterionOwnership]
  negative_path_count : Int
  execution_succeeded : Bool
  accepted : Bool
  acceptance_review_ref : String
  workspace_root : String
  artifact_paths : Array[String]
} derive(Eq, ToJson, 
Debug)

#
ConstitutionConformanceReport

source
pub(all) struct ConstitutionConformanceReport {
  contract_id : String
  report_id : String
  subject_id : String
  product_id : String
  accepted : Bool
  findings : Array[ConformanceFinding]
  checked_at : String
} derive(Eq, ToJson, 
Debug)

#
ContractKind

source
pub(all) enum ContractKind {
  Identity
  Authority
  ArtifactRef
  ExecutableDocument
  WorkModel
  KnowledgeGap
  BeliefUpdate
  BookkeeperReflection
  LearnedProcedure
  TownCommission
  TownPromotion
  ModelRoute
  RunReceipt
  BookReadiness
  EvidenceEnvelope
  ChangeReceipt
  BookMessage
  RobotDesign
  ConstitutionConformance
  AutonomyEnvelope
  AutonomyDecision
  InterventionScorecard
  BrowserSession
  BrowserActionReceiptContract
  SpatialArtifact
  RepresentationTransformContract
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
ContractKind::id

source
fn ContractKind::id(self : ContractKind) -> String

#
CriterionOwnership

source
pub(all) struct CriterionOwnership {
  criterion_id : String
  owner_product_id : String
  required_claim : ClaimClass
  negative_path_required : Bool
  evidence_refs : Array[String]
} derive(Eq, ToJson, 
Debug)

#
DeclarationKind

source
pub(all) enum DeclarationKind {
  Goal
  Research
  Build
  Decision
  Experiment
  Validation
  Acceptance
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
DeclarationKind::id

source
fn DeclarationKind::id(self : DeclarationKind) -> String

#
DisclosureLevel

source
pub(all) enum DisclosureLevel {
  User
  Operator
  Developer
} derive(Compare, Eq, Hash, ToJson, 
Debug)

The amount of operational detail requested by a Moon Suite surface.

Disclosure changes presentation only. It never changes authority, evidence, or the canonical state of a run.

#
DisclosureLevel::id

source
fn DisclosureLevel::id(self : DisclosureLevel) -> String

#
ExecutableDeclaration

source
pub(all) struct ExecutableDeclaration {
  declaration_id : String
  book_id : String
  revision : String
  kind : DeclarationKind
  title : String
  statement : String
  executor_product : String
  requires : Array[String]
  acceptance_criteria : Array[String]
  requested_authority : AuthorityClass
} derive(Eq, ToJson, 
Debug)

#
ExecutableDeclaration::quality_issues

source
fn ExecutableDeclaration::quality_issues(self : ExecutableDeclaration) -> Array[String]

#
InterventionCategory

source
pub(all) enum InterventionCategory {
  ConstitutionalAuthority
  OptionalObservation
  RequiredIntervention
  HiddenOrchestration
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
InterventionCategory::id

source

#
InterventionRecord

source
pub(all) struct InterventionRecord {
  intervention_id : String
  category : InterventionCategory
  normal_path : Bool
  product_id : String
  reason : String
  evidence_ref : String
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
InterventionScorecard

source
pub(all) struct InterventionScorecard {
  contract_id : String
  run_id : String
  constitutional_authority_count : Int
  optional_observation_count : Int
  required_intervention_count : Int
  hidden_orchestration_count : Int
  normal_path_intervention_count : Int
  unattended_qualified : Bool
  records : Array[InterventionRecord]
  checked_at : String
} derive(Eq, ToJson, 
Debug)

#
KnowledgeGap

source
pub(all) struct KnowledgeGap {
  gap_id : String
  book_id : String
  kind : CognitionGapKind
  question : String
  required_by : Array[String]
  current_evidence : Array[String]
  missing : String
  urgency : String
  resolution_criteria : Array[String]
  status : String
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
KnowledgeGap::quality_issues

source
fn KnowledgeGap::quality_issues(self : KnowledgeGap) -> Array[String]

#
LearnedProcedure

source
pub(all) struct LearnedProcedure {
  procedure_id : String
  book_id : String
  title : String
  applicability : Array[String]
  steps : Array[String]
  verification_criteria : Array[String]
  failure_modes : Array[String]
  counterexamples : Array[String]
  evidence_refs : Array[String]
  status : String
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
LearnedProcedure::quality_issues

source
fn LearnedProcedure::quality_issues(self : LearnedProcedure) -> Array[String]

#
ProductBoundary

source
pub(all) struct ProductBoundary {
  product_id : String
  owner : String
  operations : Array[String]
  allowed_authorities : Array[AuthorityClass]
  input_contracts : Array[String]
  output_contracts : Array[String]
  claim_ceiling : ClaimClass
  prohibited_claims : Array[ClaimClass]
} derive(Eq, ToJson, 
Debug)

#
ProductBoundary::quality_issues

source
fn ProductBoundary::quality_issues(self : ProductBoundary) -> Array[String]

#
RepresentationClass

source
pub(all) enum RepresentationClass {
  ReferenceBundle
  SpatialIntent
  EditableAuthoringModel
  VisualStyledModel
  EngineeringModel
  SimulationModel
  ManufacturingCandidate
  FabricationJob
} derive(Compare, Eq, Hash, ToJson, 
Debug)

The declared purpose of one spatial artifact representation.

#
RepresentationClass::id

source
fn RepresentationClass::id(self : RepresentationClass) -> String

#
RepresentationClass::is_engineering_input

source
fn RepresentationClass::is_engineering_input(self : RepresentationClass) -> Bool

#
RepresentationTransform

source
pub(all) struct RepresentationTransform {
  contract_id : String
  transform_id : String
  parent_artifact_id : String
  parent_digest : String
  parent_representation : RepresentationClass
  child_artifact_id : String
  child_digest : String
  child_representation : RepresentationClass
  lineage_relation : SpatialLineageRelation
  operation : String
  parameters_digest : String
  tool_id : String
  tool_version : String
  authority_ref : String
  declared_losses : Array[String]
  validation_refs : Array[String]
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
RepresentationTransform::quality_issues

source
fn RepresentationTransform::quality_issues(self : RepresentationTransform) -> Array[String]

#
SpatialArtifactManifest

source
pub(all) struct SpatialArtifactManifest {
  contract_id : String
  artifact_id : String
  project_id : String
  representation : RepresentationClass
  parent_artifact_ids : Array[String]
  digest : String
  payload_ref : String
  units : String
  coordinate_system : String
  up_axis : String
  handedness : String
  source_refs : Array[String]
  backend_id : String
  backend_version : String
  procedure_ref : String
  authority_envelope_id : String
  assumptions : Array[String]
  unresolved_gaps : Array[String]
  validation_refs : Array[String]
  intended_consumers : Array[String]
  forbidden_consumers : Array[String]
  claim_ceiling : ClaimClass
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
SpatialArtifactManifest::quality_issues

source
fn SpatialArtifactManifest::quality_issues(self : SpatialArtifactManifest) -> Array[String]

#
SpatialLineageRelation

source
pub(all) enum SpatialLineageRelation {
  InterpretedFrom
  ModeledFrom
  DimensionedBy
  StyledFrom
  OptimizedFrom
  CollisionDerivedFrom
  PhysicsDerivedFrom
  ManufacturingDerivedFrom
  ValidatedBy
  RejectedBy
  SupersededBy
  PlacedAs
  SimulatedAs
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
SpatialLineageRelation::id

source

#
WorkGraph

source
pub(all) struct WorkGraph {
  graph_id : String
  book_id : String
  declaration_revision : String
  items : Array[WorkItem]
  recorded_at : String
} derive(Eq, ToJson, 
Debug)

#
WorkGraph::quality_issues

source
fn WorkGraph::quality_issues(self : WorkGraph) -> Array[String]

#
WorkGraph::runnable_item_ids

source
fn WorkGraph::runnable_item_ids(self : WorkGraph) -> Array[String]

#
WorkItem

source
pub(all) struct WorkItem {
  work_item_id : String
  declaration_id : String
  product_id : String
  status : WorkStatus
  depends_on : Array[String]
  input_artifacts : Array[ArtifactRef]
  output_artifacts : Array[ArtifactRef]
  requested_authority : AuthorityClass
  attempt_count : Int
  blocker : String
} derive(Eq, ToJson, 
Debug)

#
WorkStatus

source
pub(all) enum WorkStatus {
  Proposed
  Ready
  Active
  Waiting
  Blocked
  Review
  Accepted
  Failed
  Cancelled
  Superseded
} derive(Compare, Eq, Hash, ToJson, 
Debug)

#
WorkStatus::id

source
fn WorkStatus::id(self : WorkStatus) -> String

#
WorkStatus::is_terminal

source
fn WorkStatus::is_terminal(self : WorkStatus) -> Bool

#
authority_class_from_id

source
fn authority_class_from_id(id : String) -> AuthorityClass raise

#
authorize_autonomy_event

source
fn authorize_autonomy_event(envelope : AutonomyEnvelope, event : AutonomyEventRequest, usage : AutonomyBudgetUsage, decision_id : String, checked_at : String) -> AutonomyDecision

#
autonomy_artifact_ref_is_safe

source
fn autonomy_artifact_ref_is_safe(path : String) -> Bool

#
autonomy_budget_usage_json

source
fn autonomy_budget_usage_json(usage : AutonomyBudgetUsage) -> Json

#
autonomy_digest_is_valid

source
fn autonomy_digest_is_valid(digest : String) -> Bool

#
autonomy_envelope_json

source
fn autonomy_envelope_json(envelope : AutonomyEnvelope) -> Json

#
autonomy_event_request_json

source
fn autonomy_event_request_json(event : AutonomyEventRequest) -> Json

#
autonomy_timestamp_is_canonical

source
fn autonomy_timestamp_is_canonical(timestamp : String) -> Bool

#
browser_operation_from_id

source
fn browser_operation_from_id(id : String) -> BrowserOperation raise

#
claim_class_from_id

source
fn claim_class_from_id(id : String) -> ClaimClass raise

#
compile_work_graph

source
fn compile_work_graph(graph_id : String, book_id : String, declaration_revision : String, declarations : Array[ExecutableDeclaration], recorded_at : String) -> WorkGraph

#
contract_family

source
fn contract_family() -> String

#
contract_kinds

source
fn contract_kinds() -> Array[ContractKind]

#
decode_autonomy_budget

source
fn decode_autonomy_budget(value : Json) -> AutonomyBudget raise

#
decode_autonomy_budget_usage

source
fn decode_autonomy_budget_usage(value : Json) -> AutonomyBudgetUsage raise

#
decode_autonomy_envelope

source
fn decode_autonomy_envelope(value : Json) -> AutonomyEnvelope raise

#
decode_autonomy_event_request

source
fn decode_autonomy_event_request(value : Json) -> AutonomyEventRequest raise

#
disclosure_level_from_id

source
fn disclosure_level_from_id(id : String) -> DisclosureLevel raise

#
has_required_fields

source
fn has_required_fields(kind : ContractKind, value : Json) -> Bool

#
intervention_category_from_id

source
fn intervention_category_from_id(id : String) -> InterventionCategory raise

#
intervention_scorecard

source
fn intervention_scorecard(run_id : String, records : Array[InterventionRecord], checked_at : String) -> InterventionScorecard

#
missing_required_fields

source
fn missing_required_fields(kind : ContractKind, value : Json) -> Array[String]

#
quality_dimensions

source
fn quality_dimensions() -> Array[String]

#
representation_class_from_id

source
fn representation_class_from_id(id : String) -> RepresentationClass raise

#
representation_transition_issues

source
fn representation_transition_issues(parent : RepresentationClass, child : RepresentationClass) -> Array[String]

#
required_fields

source
fn required_fields(kind : ContractKind) -> Array[String]

#
schema_json

source
fn schema_json(kind : ContractKind) -> Json

#
spatial_lineage_relation_from_id

source
fn spatial_lineage_relation_from_id(id : String) -> SpatialLineageRelation raise

#
terminal_statuses

source
fn terminal_statuses() -> Array[String]

#
validate_constitutional_conformance

source
fn validate_constitutional_conformance(registry : Array[ProductBoundary], subject : ConformanceSubject, report_id : String, checked_at : String) -> ConstitutionConformanceReport

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io