engmodel

package module

v0.6.0 Latest Latest Go to latest Published: Oct 30, 2026 License: MIT Imports: 17 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/labeth/engineering-model-go

Links

Open Source Insights

README ¶

engineering-model-go

engineering-model-go is a Go library and CLI for generating architecture views and AsciiDoc documentation from a typed engineering model.

It combines:

architecture model loading and validation
viewpoint projection (architecture-intent/communication/deployment/security/traceability)
Mermaid rendering
Structurizr DSL export
Threat Dragon/Open Threat Model JSON export
TRLC requirements export
LOBSTER activity trace export
design + requirement narrative generation to AsciiDoc
EARS requirement preflight linting
code trace mapping (Go, Python, JavaScript, TypeScript, Rust, Verilog modules)

YAML remains the canonical authored and persistence format, with CUE as the authoritative schema and cross-field constraint layer. The canonical YAML/CUE model is a semantic superset of the pinned formal SysML 2.0/KerML 1.0 abstract syntax, with typed Engineering:: extensions. This is evidenced by exhaustive inventory coverage, official-parser validation, and semantic project-interchange round trip. It does not claim execution/simulation semantics or graphical concrete syntax. SysML textual DSL is generated output, not another source model. See docs/sysml-v2-superset-plan.md.

Each model directory has one schema-v2 manifest entry point and eight required domain documents. An optional ninth documents.aviation document adds an airborne software evidence-readiness profile without changing models that omit it:

schemaVersion: 2
module:
  path: models.example/example-system@v0
  version: v0.1.0
  modelId: example-system
  title: Example System
  introduction: Example schema-v2 model.
  kind: system
documents:
  catalog: model/catalog.yml
  requirements: model/requirements.yml
  architecture: model/architecture.yml
  behavior: model/behavior.yml
  assurance: model/assurance.yml
  compliance: model/compliance.yml
  views: model/views.yml
  decisions: model/decisions.yml
  # aviation: model/aviation.yml
dependencies: []
publications:
  - id: public
    architecture: [FU-EXAMPLE]
    requirements: [REQ-EXAMPLE-001]
inferenceHints: {}

engmod.yml is the only model entry point. Every manifest and domain document uses schemaVersion: 2; paths are explicit and no companion filename is inferred. AI agents should call the no-argument MCP tool model.authoringContract first; it returns the resolved document set, schema files, top-level YAML fields, stable-ID conventions, dependency/source rules, and recommended editing order without requiring a broad repository scan.

Scope

This project models development-state architecture inputs from YAML and produces deterministic documentation/view artifacts.

It is not a runtime observability or incident/compliance runtime system.

Features

CUE-backed, closed-schema YAML loading for architecture, catalog, requirements, decisions, and design documents, followed by strict Go decoding
format-neutral document definitions and document-control metadata for downstream formal-document generators
model validation for IDs, references, relations, and viewpoint configuration
expanded mapping relation taxonomy for communication/deployment/security/traceability/lifecycle semantics
catalog-linked architecture relation labeling
deployment view extraction from:
- Terraform (.tf) using HashiCorp HCL parsing
- Flux resources (GitRepository/Kustomization/HelmRelease)
- Helm chart metadata via Helm SDK chart loader
deterministic Mermaid view rendering
canonical semantic projection with stable IDs, typed relationships, ownership, source metadata, and explicit unsupported/lossy diagnostics
deterministic SysML v2 textual projection and executable coverage manifest
optional DO-178C/ED-12C evidence-readiness modeling and deterministic draft package generation; this is not a compliance or certification determination
AsciiDoc architecture generation with chapter scope diagrams
view-level filtering controls (includeKinds, excludeKinds, includeMappings, excludeMappings, maxDepth)
EARS preflight linting via github.com/labeth/ears-lint-go
- lintRun.mode: strict is the default and recommended project mode
- guided is optional for drafting workflows and non-blocking author guidance
Tree-sitter based code symbol extraction and trace mapping for:
- Go
- TypeScript/TSX
- JavaScript (.js, .mjs, .cjs): named functions/generators, methods, classes and directly bound function values. Anonymous callbacks and top-level statements are not independent declarations; this does not infer classic-script load order or runtime behavior. Syntax errors and multiple declarations on one line produce errors rather than ambiguous trace credit.
- Python (.py): functions (including async and nested definitions), methods and classes. Decorated declarations retain their definition-line coordinates; multiline decorators do not detach preceding trace comments. Strings and docstrings cannot create trace or ownership markers. Syntax errors fail declaration coverage. Lambdas and top-level script effects are outside this declaration scope. test_*.py and *_test.py are verification sources, with not-run status until result evidence is supplied.
- Rust
Lexical Verilog (.v) module trace extraction, with one requirement-link block per module. This does not validate HDL syntax, elaborate designs, or expand macros. Unresolved macro invocations that may affect module declarations and malformed module boundaries produce errors. Macros recognized in expression positions inside a module produce warnings requiring independent build evidence; conditional branches are all inspected. The whole module root is scanned; inferenceHints.exclude takes glob patterns (dir/** for subtrees) for paths to leave out. Linked tb_*.v and *_tb.v testbenches produce verification links with not-run status until result evidence is supplied. Test-source links do not count as production implementation in the trace matrix.

Installation

go get github.com/labeth/engineering-model-go

Library API

The root package engmodel is the only public Go API; every other package is under internal/. It re-exports the model and validation types, so callers do not import the internal packages:

bundle, err := engmodel.LoadBundle("engmod.yml") // engmodel.Bundle, engmodel.Requirement, ...
if err != nil {
    panic(err)
}
diags := engmodel.SortDiagnostics(engmodel.ValidateBundle(bundle))
if engmodel.HasErrors(diags) {
    // report []engmodel.Diagnostic
}

Model: LoadBundle, LoadCanonicalBundle, NewCanonicalBundle, ProjectSemanticModel, BuildAuthoringContract, LoadWorkspace, FindWorkspace, FindWorkspaceWith. Validation: ValidateBundle, HasErrors, SortDiagnostics, DedupeDiagnostics, AuthoringRules (returns ValidationRules).

Primary entry points:

GenerateFromFile(architecturePath, viewID)
Generate(bundle, viewID)
GenerateAsciiDocFromFiles(architecturePath, requirementsPath, designPath, options)
GenerateStructurizrDSLFromFile(architecturePath)
ProjectSemanticModel(bundle)
GenerateSysMLV2FromFile(architecturePath)
GenerateSysMLV2(bundle)
GenerateAirborneAssuranceFromFile(manifestPath, options)

For a model that declares documents.aviation, generate the readiness package:

go run ./cmd/engair --model engmod.yml --out-dir generated/do178c \
  --date 2026-09-19 --version v0.1.0

The package is visibly marked DRAFT / NOT A COMPLIANCE OR CERTIFICATION DETERMINATION, identifies exact authored baselines and open gaps, and uses only customer-supplied opaque objective references. See examples/dal-c-flight-control-sample/.

GenerateSysMLV2Projection(semanticModel)
SysMLV2Coverage()
GenerateThreatModelExportFromFile(architecturePath, options)
GenerateTRLCRequirementsFromFile(requirementsPath, options)
GenerateLobsterActivityTraceFromDir(testsDir, options)
BuildTraceMatrixFromFiles(architecturePath, requirementsPath, options)

Example:

res, err := engmodel.GenerateFromFile("examples/payments-engineering-sample/engmod.yml", "VIEW-ARCHITECTURE-INTENT")
if err != nil {
    panic(err)
}

fmt.Println(res.Mermaid)
for _, d := range res.Diagnostics {
    fmt.Printf("%s [%s] %s\n", d.Code, d.Severity, d.Message)
}

View IDs are free-form, but view kind must be one of:

architecture-intent
communication
deployment
security
traceability
state-lifecycle (optional)
interaction-flow (optional)

Optional view projection controls in model/views.yml:

includeKinds / excludeKinds: node kind filtering
includeMappings / excludeMappings: relation type filtering
maxDepth: bounded traversal from roots (0 means unlimited/default behavior)
audience, abstraction: optional publication metadata

Formal-document consumers can select canonical model content without adding format-specific payloads:

documents:
  - id: DOC-SYSTEM-SPECIFICATION
    title: System Specification
    kind: system-requirements-specification
    purpose: Define the system requirement baseline.
    audience: [systems-engineering, verification]
    stakeholderRefs: [ACT-SYSTEMS-ENGINEER]
    referenceRefs: [REF-SOURCE-SPECIFICATION]
    contentRefs: [REQ-SYSTEM-001, FU-CONTROL, VIEW-LOGICAL]
    sections:
      - id: scope
        title: Scope
        narrative: Defines the system boundary and intended use.
        includeRefs: [FU-CONTROL]
    control:
      identifier: SYS-SPEC-001
      revision: "1.0"
      status: draft
      issuedBy: Example Organization
      issueDate: 2026-09-20
      language: en
      documentType: specification
      confidentiality: internal
      securityClassification: unclassified
      exportControlled: false
      countryOfOrigin: Sweden
      confidentialityStamp: false

Requirements may additionally declare title, category, rationale, sourceRefs, verificationMethods, verificationCriteria, priority, criticality, status, derived, derivedRationale, and tags. These fields remain generic model input; exporters use only fields that have a native representation in their target format.

Authored architecture optionally supports additional first-class entities:

interfaces
dataObjects
deploymentTargets
controls
trustBoundaries
states
events
flows (with ordered steps)
hardwareItems (physical items with DO-254 DAL safety levels, part numbers, suppliers)
hardwareInterfaces (HW/SW interface contracts: ICD/IRS with buses such as arinc429, can, spi, i2c, ethernet, cellular)

Structural composition entities in model/architecture.yml:

contract (the system's provides/requires public interface contract)
composition.subsystems (downward references to child system models)
composition.allocations (parent-requirement allocation onto a subsystem or hardware item)
composition.satisfactions (records of how a subsystem's required interface is satisfied by a provider)

engdoc renders HW/SW interface allocation views from hardwareItems, hardwareInterfaces, and composition.allocations. See System-of-Systems Composition for the composition gates.

Flow step fields (model/behavior.yml behavior.flows[].steps[]) support:

id, ref, kind, action
dataIn, dataOut
next, onError
async, optional

Assurance authoring fields in model/assurance.yml:

controls
risks
poamItems

OSCAL catalog/profile integration is authored in model/compliance.yml:

compliance.profiles[]: OSCAL profile/catalog sources for the selected baseline
compliance.mappings[]: maps local CTRL-* implementation controls to selected OSCAL controlIds and architecture appliesTo entities; unmapped controls remain local model controls and are not exported as OSCAL implementations

Expanded mapping relation vocabulary includes:

Base: contains, depends_on, interacts_with, targets
Communication/data: calls, publishes, subscribes, reads, writes, streams
Traceability/deployment: implements, satisfies, allocated_to, verified_by, deployed_to
Security/lifecycle: mitigated_by, bounded_by, transitions_to, triggered_by, guarded_by
Flow projection (view-only): flow_next, flow_error, flow_async, flow_ref

bounded_by links a functional unit, deployment target, interface, actor, hardware item or data object to a trust boundary. Default security views retain these member kinds. Membership describes the modeled boundary; it does not establish authentication or enforcement. Author an explicit relationship when it should appear in the projected view.

Optional per-view publication metadata (in model/views.yml):

authoredStatus (for example draft, in-review, stable)
authoredStatusExplanation (short rationale shown in Document Health Snapshot)

Verification metadata is inferred from test artifacts:

test sources under tests/ (for inferred verification checks and test code element links)
result artifacts under test-results/ (for inferred requirement-level outcomes)
requirement IDs in test sources are inferred from TRLC-LINKS: REQ-* markers
requirement IDs in result artifacts are inferred by matching REQ-* tokens in result content
published verification chain is Verification Check -> Test Code Element -> Requirement
functional ownership in verification tables is shown as derived context from requirement ownership
strict EARS lint also warns when catalog terms (systems, actors, events, states, features, modes, conditions, data terms) are referenced nowhere in the model (catalog.term_unreferenced): a term counts as referenced when its id is used by a model document or its name or an alias appears in requirement text, notes, verification criteria or rationale, another catalog entry's name or definition, or any architecture, behavior, assurance, compliance, views or decisions text
lint.multiple_responses is not reported for one response verb whose conjunctions all sit in a trailing with, including or of field list (shall publish one world state message with UTC time, latitude, longitude and altitude); a conjunction before the list, a second shall, a then in the list, or a list item that reads as a verb with its object (… with the timestamp and notify the operator) is still reported
a control verification names its tests in verificationRefs: inferred CODE-<PATH>--<NAME> IDs of test declarations or REQ-* IDs whose linked tests verify it. verification.status_stale warns at the status of a control verification that is unset or not-run, and of a threat mitigation that is unset or planned, while those tests exist in the code; the status stays authored

Model warnings

Beyond the hard errors, validation warns about model content that is declared but not wired (warnings do not fail engdoc):

Code	Reported at	Rule
`behavior.event_unused`	`authoredArchitecture.events[i]`	a behavior event no `triggered_by` relationship targets, no semantic transition lists as a trigger and no semantic relationship, flow or flow step references
`behavior.state_unreachable`	`authoredArchitecture.states[i]`	with at least one transition in the model, a state other than the first declared one (the initial state; the schema has no initial marker) that no `transitions_to` or semantic transition enters
`behavior.flow_step_no_onerror`	`authoredArchitecture.flows[i].steps[j].onError`	a step with `boundaryCrossing: true` and no `onError`
`catalog.name_has_operator`	`catalog.<group>[i].name` or `.aliases[j]`	an actor, event, state, feature, mode, condition or data term name or alias with a standalone `and`, `or`, `not`, a comma or a parenthesis, which the EARS clause parser reads as operators
`verification.status_stale`	`…controlVerifications[i].status`, `…threatMitigations[i].status`	the referenced tests exist but the status still says they have not run (see above); reported by `engdoc` and `engtrace`

Code trace markers

Source files link back to the model with two comment markers, scanned under --code-root:

TRLC-LINKS: lists requirement IDs (REQ-*) implemented or exercised by the code
ENGMODEL-LINKS: lists model element IDs (functional units, interfaces, controls, flows, data objects, etc.) realized by the code

Both markers are validated against the loaded model. Unresolved IDs are hard errors (code.dangling_requirement_link for TRLC-LINKS, code.dangling_model_link for ENGMODEL-LINKS), enforced by the engdoc zero-error gate and by engtrace (non-zero exit). Code is scoped to its nearest enclosing model root, so links resolve against the closest model rather than the whole tree. Requirements with no implementing or delegating code surface a requirement.orphan warning, and a requirement linked from code that does not exist raises requirement.internal_link.

CLI Usage

Plan, inspect, and atomically apply a requirements delta:

# requirements-delta.yml
version: 1
requirements:
  add:
    - id: REQ-PAY-011
      text: "When payment authorized event is received, the payments system shall persist authorization record."
      notes: "New audit behavior."
      appliesTo: [FU-PAYMENT-AUTHORIZATION]
  update: []
  remove: []

go run ./cmd/engchange validate --root examples/payments-engineering-sample --delta requirements-delta.yml
go run ./cmd/engchange diff --root examples/payments-engineering-sample --delta requirements-delta.yml
go run ./cmd/engchange apply --root examples/payments-engineering-sample --delta requirements-delta.yml

Delta version 1 supports requirement add, whole-entity update, and remove operations. Planning and diffing never write canonical files. Apply validates the complete candidate model, preserves unchanged YAML nodes and comments, and atomically replaces model/requirements.yml only when no blocking diagnostics are present.

Render OpenSpec spec delta text from model requirements (also engmodel.RenderSpecDelta); each REQ-…: line starts with the model text, so a pasted spec stays consistent with the model:

go run ./cmd/engspec --model examples/dal-c-flight-control-sample/engmod.yml \
  --prefix REQ-YD- --capability yaw-damping

Generate a single Mermaid view:

go run ./cmd/engview \
  --model examples/payments-engineering-sample/engmod.yml \
  --view VIEW-DEPLOYMENT \
  --out out.mmd

Generate every authored view as deterministic Mermaid and native SVG:

go run ./cmd/engview \
  --model examples/coffee-appliance-six-view/engmod.yml \
  --out-dir examples/coffee-appliance-six-view/generated

The coffee appliance fixture demonstrates use-case, logical, process, physical, implementation, and deployment concerns from canonical schema-v2 semantics. Its process output is a Mermaid sequence diagram, and every SVG includes an accessible title plus source and view provenance.

Generate architecture AsciiDoc:

go run ./cmd/engdoc \
  --model examples/payments-engineering-sample/engmod.yml \
  --requirements examples/payments-engineering-sample/model/requirements.yml \
  --design examples/payments-engineering-sample/model/views.yml \
  --code-root ./src \
  --view VIEW-ARCHITECTURE-INTENT \
  --view VIEW-TRACEABILITY \
  --decisions-out examples/payments-engineering-sample/generated/DECISIONS.adoc \
  --out examples/payments-engineering-sample/generated/ARCHITECTURE.adoc

--view is repeatable to scope the document to specific viewpoint IDs (omit to include all configured views). When --decisions-out is set, engdoc emits the architecture decision records (from model/decisions.yml) as a separate DECISIONS.adoc document.

Each authored view and each requirement coverage graph is published as one complete diagram. Large diagrams scale to fit the page instead of being split into repeated panels. Standalone Mermaid and SVG exports preserve the same complete graph and can be viewed at a larger scale. Deployment publications shorten relationship labels longer than 32 characters to numbered arrows and retain their full text in a table directly below the diagram. Extra routing space separates keyed edges; standalone graph exports retain the original labels. Browser and requirement flowcharts use wider spacing to reduce label collisions without removing nodes or relationships.

Generate the machine-readable traceability matrix:

go run ./cmd/engtrace \
  --model examples/payments-engineering-sample/engmod.yml \
  --requirements examples/payments-engineering-sample/model/requirements.yml \
  --code-root examples/payments-engineering-sample/src \
  --format json \
  --out examples/payments-engineering-sample/generated/TRACE-MATRIX.json

Use --format csv for a spreadsheet-friendly matrix instead. The emitted matrix rolls up per-requirement status (implemented/verified/delegated/orphan) together with code references and delegations. engtrace exits non-zero when it finds dangling code trace links (code.dangling_requirement_link / code.dangling_model_link), so it doubles as a CI gate.

Generate Threat Dragon/Open Threat Model exports:

go run ./cmd/engdragon --model examples/payments-engineering-sample/engmod.yml --format threat-dragon-v2 --out examples/payments-engineering-sample/generated/threat-dragon-v2.json
go run ./cmd/engdragon --model examples/payments-engineering-sample/engmod.yml --format open-otm --out examples/payments-engineering-sample/generated/open-threat-model.json

Generate Structurizr DSL:

go run ./cmd/engstruct --model examples/payments-engineering-sample/engmod.yml --out examples/payments-engineering-sample/generated/STRUCTURIZR.dsl

Generate the deterministic SysML v2 textual projection:

go run ./cmd/engsysml \
  --model examples/payments-engineering-sample/engmod.yml \
  --out examples/payments-engineering-sample/generated/architecture.sysml

Author NATO Architecture Framework 4.1 metadata in model/views.yml without duplicating the canonical architecture graph:

naf:
  framework: NAF
  version: "4.1"
  architectureDescription: Example NAF Architecture Description
  stakeholders:
    - actorRef: ACT-ARCHITECT
      role: Owns architecture decisions.
  concerns:
    - id: NAF-CONCERN-STRUCTURE
      name: System structure
      stakeholderRefs: [ACT-ARCHITECT]
  products:
    - id: NAF-P2-RESOURCE-STRUCTURE
      viewpoint: P2
      title: Physical resource structure
      viewRef: VIEW-DEPLOYMENT
      concernRefs: [NAF-CONCERN-STRUCTURE]

Each NAF product references an existing Engmod view. Capability, service, logical, resource, interface, behavior, and requirement concepts therefore remain represented once in the canonical SysML/KerML-aligned model. Generate the deterministic NAF architecture document with:

go run ./cmd/engnaf \
  --model engmod.yml \
  --out generated/ARCHITECTURE.naf.adoc

The profile accepts the official NAF 4.1 viewpoint codes (C*, S*, L*, P*, and A*, including roadmap and cross-domain viewpoints). CUE rejects unsupported framework versions and viewpoint codes; model validation also checks actor, stakeholder, concern, and Engmod view references. This output is a framework-aligned architecture description and is not a claim of NATO certification.

Emit the executable metaclass/property-level coverage manifest:

go run ./cmd/engsysml --coverage

The formal metamodel inventory is separate from that projection report. The formal Systems-Modeling/SysML-v2-Release tag 2026-04 is pinned at commit 9baca5908ca28b53da085de69336fde48420ea8f. That release does not contain a normative metamodel XMI/Ecore: its XMI directories are standard-library model instances, and the release notes explicitly state that their Eclipse XMI is not fully normative OMG XMI.

The closest official machine-readable metamodel artifact is therefore the Ecore published by the aligned official Pilot Implementation tag 2026-04, commit 20897e3122f2c2f8b29389745f0caaaeb7c6e21a:

Origin	Path	SHA-256
KerML 1.0	`org.omg.sysml/model/kerml.ecore`	`62db52cbccf41266ccfa9b3b9cbb4a40384f16ab513f1d8522fd29d9d0fda8e7`
SysML 2.0	`org.omg.sysml.model/src/main/resources/model/SysML.ecore`	`be71998ca0d9bb7e6081a25e8ead93ce49d623a47ca414b30ee8c572d6d0d753`

Exact immutable URLs and authority notes are tracked in internal/export/sysml/metamodel/metamodel-sources.json. Refresh downloads into the ignored .engmod/cache tree, verifies both hashes, and regenerates the compact inventory and semantic coverage binding:

scripts/refresh-sysml-metamodel.sh
scripts/check-sysml-metamodel.sh

The offline check uses only tracked artifacts. It inventories exactly 175 metaclasses, 415 owned properties, 13,318 effective properties, 209 inheritance edges, 328 derived properties, and 66 relationships. The strict binding records 262 mapped entries, 328 derived/implied entries, and zero unimplemented entries. Textual rendering classifies 54 metaclasses as native-rendered and 121 as abstract/implicit, with zero missing rules; all 66 relationships are classified. CI rejects stale inventory hashes, omitted properties or renderer classifications, partial/unsupported normative statuses, stale coverage JSON, official-parser failures, and semantic round-trip differences.

Install the pinned official parser wrapper and Sysand KPAR packager into the ignored .engmod tool/cache tree:

scripts/install-sysml-toolchain.sh

The installer verifies the official 2026-04 Pilot Implementation jupyter-sysml-kernel-0.59.0.zip checksum and the platform-specific Sysand 0.2.1 release checksum. The validator wrapper is checked out at commit 63abbd9fbc7851dc437d01b2dc07836b919770b8; GitHub does not publish a separate source-archive checksum for that commit, so the immutable Git object ID is the documented verification boundary.

Build and reopen a normative KPAR through Sysand:

go run ./cmd/engsysml \
  --model engmod.yml \
  --project-out .engmod/validation/sysml/project \
  --kpar-out .engmod/validation/sysml/engineering-model.kpar \
  --sysand .engmod/tooling/bin/sysand

go run ./cmd/engsysml \
  --model engmod.yml \
  --verify-kpar .engmod/validation/sysml/engineering-model.kpar \
  --reopen-out .engmod/validation/sysml/reopened \
  --sysand .engmod/tooling/bin/sysand

engsysml delegates KPAR creation and reopening to Sysand; it does not create or label a custom ZIP as KPAR. The generated project contains only native SysML source; engineering-model data without a native SysML representation is omitted rather than embedded in descriptions, metadata payloads, or extension bags. Verification reopens the KPAR and compares its SysML source byte-for-byte with a fresh deterministic projection. Run the complete blocking gate with scripts/validate-sysml.sh. Local users may explicitly skip unavailable external tools with ENGMOD_SYSML_SKIP_EXTERNAL=1 scripts/validate-all.sh; CI installs the pinned tools and never sets that skip.

The exporter preserves engineering-specific concepts and source properties in a typed metadata payload and reports unsupported, lossy, external-endpoint, and toolchain-conformance limitations as diagnostics. The generated text and KPAR are validated by the official parser baseline, but the coverage manifest still describes a documented subset/projection rather than claiming complete SysML v2 semantic conformance.

Every authored YAML document is validated against the embedded modular schemas in internal/model/schema/ before strict Go decoding. CUE is authoritative for document shape and cross-field constraints, produces path-aware diagnostics, and rejects unknown fields recursively. A reflection-based contract test detects drift between CUE fields and the Go runtime API representations. The loader aggregates the domain documents into one canonical semantic graph for validation and projection.

Generate TRLC requirements package:

go run ./cmd/engtrlc --requirements examples/payments-engineering-sample/model/requirements.yml --out-dir examples/payments-engineering-sample/generated/trlc --package PaymentsRequirements

Generate LOBSTER activity trace from tests:

go run ./cmd/englobster --tests-dir examples/payments-engineering-sample/tests --requirements-package PaymentsRequirements --activity-namespace tests --out examples/payments-engineering-sample/generated/lobster/activities.lobster

Regenerate all maintained examples with scripts/generate-examples.sh. After generation, scripts/render-publication-pdfs.sh renders the self-model and every example architecture publication using the locally installed proven-docs. Review the rendered pages before release; a successful render does not establish visual quality. PDF rendering is separate from deterministic model-export validation.

Render an individual PDF with proven-docs:

proven-docs render \
  examples/payments-engineering-sample/generated/ARCHITECTURE.adoc \
  --output examples/payments-engineering-sample/generated/ARCHITECTURE.proven.pdf

The generated document starts with:

Introduction (from model.introduction)
Scope and Assumptions
How To Read This Document
Document Health Snapshot (per-view coverage and confidence)
Terms and Definitions as a compact Term | Definition table
- terms are sorted A-Z by term text
- term IDs are shown as Term (ID) in the term column

Each generated view includes:

What This View Answers
Coverage Gaps and Recommended Next Evidence Additions
view-scoped narratives from model/views.yml
- for security, content is organized as attack-vector chapters with per-attack diagrams and related FU sections

The Traceability View includes:

Requirement-to-Unit Mapping (Compact)
Verification Result Mapping (inferred per-requirement outcomes)

The traceability appendix includes:

Requirement Details
Verification Inventory (inferred test/check mappings to test code elements and requirements)
Reference Index with consistent entry layout:
- chapter per ID
- short prose description
- compact key/value table with the most relevant fields
- Mentioned In backlinks to jump from registry entries to sections where each entry is referenced
- sections: Authored References, Catalog References, Inferred Runtime References, Inferred Code References, Verification References

Machine-oriented development context is exposed through the MCP server.

Run the MCP server (Model Context Protocol, stdio JSON-RPC over Content-Length-framed messages on stdin/stdout):

go run ./cmd/engmcp

It exposes 50+ tools grouped into families, including:

requirements.*: requirement details, impact, support paths, and edit-plan suggestions
files.*: files and ownership for a requirement, control, or threat
verification.*: inferred verification status, gaps, and recommendations
threats.*: threat coverage, per-requirement threats, and unmitigated threats
flows.*: interaction-flow projections and diffs per requirement
graph.*: model graph search, neighborhood, and edge explanations
model.*: model entity lookup, listings, implementations, and RSL export
interfaces.*: software and HW/SW interface resolution and code matching
composition.resolve: the system-of-systems — subsystems, contracts, requirement allocations with the delegated subsystem requirement, and composition diagnostics
trace.matrix: summary (requirements, implemented, tested/testLinked, passed, delegated, orphan, dangling; verified is a deprecated alias of testLinked), per-requirement status, code references, and dangling code trace links; summaryOnly: true returns only the summary and diagnostics
gemara.*: one tool per OpenSSF Gemara artifact type plus gemara.validate

Additional export/validation docs:

MCP-first agent workflow and tagging contract: docs/skills/architecture-mcp-workflow.md
OSCAL profile/catalog and compliance mapping workflow: docs/oscal-compliance-mapping.md
Threat Dragon export and schema checks: docs/threat-dragon-export-testing.md
Structurizr export and validation: docs/structurizr-export-testing.md
TRLC requirements export and validation: docs/trlc-export-testing.md
TRLC + LOBSTER traceability report pipeline: docs/lobster-traceability.md

System-of-Systems Composition

A model declares exact dependencies in engmod.yml and composes their selected publications from model/architecture.yml.

# engmod.yml
dependencies:
  - alias: telemetry
    path: models.example/coffee-fleet/telemetry@v0
    version: v0.1.0
    publications: [public]

# model/architecture.yml
architecture:
  composition:
    subsystems:
      - id: SUB-TELEMETRY
        name: Machine Telemetry Subsystem
        dependency: telemetry
        publication: public
    allocations:
      - requirement: REQ-COF-001
        to: SUB-TELEMETRY
        target: telemetry::CAP-TELEM-REPORT
        rationale: Reporting is realized by the telemetry subsystem.
    satisfactions:
      - need: ota-agent::NEED-TELEMETRY-FEED
        by: telemetry::CAP-TELEM-REPORT

Dependencies are standard CUE modules fetched from the OCI registry selected by CUE_REGISTRY and materialized under .engmod/modules. A module contains cue.mod/module.cue, engmod.yml, and the eight domain documents:

module: "models.example.com/company/security@v0"
language: version: "v0.17.0"

Publish with the standard CUE workflow:

export CUE_REGISTRY=registry.example.com/company-models
cue mod tidy
cue mod publish v0.3.1

For multi-repository local development, place engmod.work.yml above the repositories. Published coordinates stay unchanged while dependencies resolve from explicit sibling paths:

schemaVersion: 2
replacements:
  - module: models.example.com/company/security@v0
    path: ./repos/security

Replacement paths must remain inside the workspace and their cue.mod/module.cue identity must match. Composition rejects floating or invalid versions, path escapes, cycles, missing manifests, unpublished targets, and unsatisfied requirements.

To prove a family's release order and run the pre-push gate before anything is pushed, stage every checkout under the workspace root (go run ./cmd/engws help has the details):

engws stage --serve          # foreground: loopback OCI registry for the staged CUE modules
# in another shell, export the printed lines, then in each checkout, dependencies first:
export CUE_REGISTRY=<printed> GOPROXY=file://<root>/.engmod/staging/goproxy,off
export GONOPROXY=none GONOSUMDB=<printed> GOWORK=off ENGMOD_WORK=off
ENGMOD_LOCK=check <pre-push gate>

engws stage writes only <root>/.engmod/staging: registry/<module path>/ (an OCI image layout per CUE module, the content cue mod publish would push: committed files for source kind git) and goproxy/ (a GOPROXY file tree for each checkout with go.mod). CUE has no file-based registry, so --serve serves the layouts from memory on 127.0.0.1.

See examples/coffee-fleet-ota-cloud-sample for local composition and examples/atlas-industries for a seven-repository company portfolio with two products reusing shared hardware/software, security, compliance, and cloud modules through OCI coordinates.

Requirement delegation (no tiers)

Delegation is flat — there are no requirement tiers. A parent requirement is satisfied by delegating it to a subsystem contract entry, expressed as a composition.allocations entry that binds the requirement to a subsystem (target naming the provided contract id within that subsystem). A delegation without a resolvable target raises composition.untraceable_delegation. A delegated requirement counts against the requirement.orphan rollup, so a requirement that is neither implemented in code nor delegated to a subsystem still surfaces as orphaned.

OSCAL chain generation

Use engoscal to generate SSP, Assessment Results, and POA&M artifacts from architecture inputs.

SSP only:

go run ./cmd/engoscal --model examples/payments-engineering-sample/engmod.yml --ssp-out examples/payments-engineering-sample/generated/ARCHITECTURE.ssp.json

Full chain:

go run ./cmd/engoscal \
  --model examples/payments-engineering-sample/engmod.yml \
  --requirements examples/payments-engineering-sample/model/requirements.yml \
  --code-root examples/payments-engineering-sample/src \
  --profile examples/payments-engineering-sample/oscal/profile-nist-800-53-low.json \
  --catalog examples/payments-engineering-sample/oscal/catalog-nist-800-53-rev5-subset.json \
  --ssp-out examples/payments-engineering-sample/generated/ARCHITECTURE.ssp.json \
  --ar-out examples/payments-engineering-sample/generated/ARCHITECTURE.ar.json \
  --poam-out examples/payments-engineering-sample/generated/ARCHITECTURE.poam.json \
  --ap-href ./ASSESSMENT-PLAN.json \
  --ssp-href ./ARCHITECTURE.ssp.json

Validation with OSCAL CLI (containerized):

podman run --rm -v "$PWD":/work:Z -w /work docker.io/matthewruge/oscal-cli:0.2.0 ssp validate --as json examples/payments-engineering-sample/generated/ARCHITECTURE.ssp.json
podman run --rm -v "$PWD":/work:Z -w /work docker.io/matthewruge/oscal-cli:0.2.0 ar validate --as json examples/payments-engineering-sample/generated/ARCHITECTURE.ar.json
podman run --rm -v "$PWD":/work:Z -w /work docker.io/matthewruge/oscal-cli:0.2.0 poam validate --as json examples/payments-engineering-sample/generated/ARCHITECTURE.poam.json

Gemara GRC rendering

Gemara is a first-class rendering of the model: enggemara projects the engineering model into OpenSSF Gemara documents using the official go-gemara SDK types, and every artifact validates against the published Gemara CUE schemas.

All 13 Gemara artifact types are produced:

L1 Vector Catalog ← attackVectors (with environment applicability)
L1 Principle Catalog ← standard governance principles
L1 Guidance Catalog ← control families (control guidelines link back to it)
L2 Capability Catalog ← functionalUnits (+ a synthetic system capability)
L2 Threat Catalog ← threatScenarios (capabilities, vectors, and threat actors)
L2 Control Catalog ← controls + controlVerifications (synthesized assessment-requirements)
L3 Risk Catalog ← risks (severity derived from likelihood × impact; unique rank)
L3 Policy ← compliance/risks/controls (scope, imports, risk treatment, adherence)
L5 Evaluation Log ← controlVerifications (pass and fail, with evidence)
L6 Enforcement Log ← poamItems (remediation actions)
L7 Audit Log ← controlVerifications + residual risks
Mapping Document ← control → threat relationships
Lexicon ← catalog terms (controlled vocabulary)

Generate the catalogs and logs:

go run ./cmd/enggemara \
  --model examples/payments-engineering-sample/engmod.yml \
  --requirements examples/payments-engineering-sample/model/requirements.yml \
  --out-dir examples/payments-engineering-sample/generated/gemara \
  --version 1.0.0 --date 2026-06-26T00:00:00Z

Optionally emit OSCAL via the Gemara SDK bridge (additive; the hand-written OSCAL SSP/AR/POA&M under engoscal are retained):

go run ./cmd/enggemara --model <engmod.yml> --requirements <model/requirements.yml> \
  --out-dir <dir> \
  --oscal-catalog-out <dir>/oscal-catalog.json \
  --oscal-ar-out <dir>/oscal-ar.json

Validation:

in-repo, via the go-gemara SDK loader + type discriminator: go test -run TestGemara ./...
against the official CUE schemas: scripts/validate-gemara.sh (needs the cue CLI and the Gemara schema module; set GEMARA_SCHEMA_DIR to a checkout of github.com/gemaraproj/gemara)

The generated AsciiDoc document includes a Gemara GRC Model chapter, and the MCP server exposes a gemara.* tool per artifact type (gemara.controlCatalog, gemara.threatCatalog, gemara.riskCatalog, gemara.vectorCatalog, gemara.capabilityCatalog, gemara.principleCatalog, gemara.guidanceCatalog, gemara.policy, gemara.lexicon, gemara.mappingDocument, gemara.auditLog, gemara.enforcementLog, gemara.evaluationLog) plus gemara.validate.

See docs/gemara-rendering.md for the field-by-field mapping and the OSCAL decision.

Agent Skills

Use these docs to drive AI-agent development workflows and tagging conventions:

OpenCode-ready skill (auto-discoverable by opencode debug skill): .opencode/skills/engineering-model-architecture-ai/SKILL.md
framework-neutral workflow and tagging contract: docs/skills/architecture-mcp-workflow.md
OpenCode adapter prompt: docs/skills/adapters/opencode-skill-prompt.md
generic adapter prompt for other frameworks: docs/skills/adapters/generic-agent-prompt.md

Example Project

End-to-end sample inputs and generated outputs are under:

examples/payments-engineering-sample
examples/bedrock-pr-review-github-app-sample
examples/coffee-fleet-ota-cloud-sample

Core files:

engmod.yml
model/catalog.yml
model/requirements.yml
model/architecture.yml
model/behavior.yml
model/assurance.yml
model/compliance.yml
model/views.yml
model/decisions.yml
infra/terraform
src (Go/Rust/TypeScript traced code)

Development

Repository layout

.
├── doc.go, model_api.go,       public engmodel facade: type aliases, constants and thin
│   validate_api.go, api_*.go   wrappers, one api_<area>.go per area (old public names kept)
├── facade_test.go              every exported implementation name is re-exported at the root
├── layering_test.go            the package import direction below holds
├── cmd/                        command-line tools (engdoc, engview, engtrace, engchange, engspec,
│                               enggemara, engoscal, engsysml, engstruct, engdragon, engnaf,
│                               engtrlc, englobster, engair, engmcp, engws, sysmlmetamodel)
├── internal/
│   ├── model/                  model types, loader, canonical bundle, embedded CUE schema (schema/)
│   ├── validate/               diagnostics and bundle validation rules
│   ├── codemap/                tree-sitter and lexical source symbol scanner
│   ├── view/                   view projection of the architecture
│   ├── render/                 diagramstyle, mermaid and svg renderers of a projected view
│   ├── composition/            system-of-systems composition (CUE modules, workspace, lock)
│   ├── codescan/               code, runtime and verification evidence inference
│   ├── trace/                  traceability matrix
│   ├── reqlint/                EARS preflight, catalog description and requirement link lint
│   ├── reqdelta/               requirements delta planning and atomic application, spec delta rendering
│   ├── generate/               single-view Mermaid/SVG generation (Generate, GenerateFromFile)
│   ├── asciidoc/               AsciiDoc publication (templates/asciidoc.tmpl)
│   ├── export/                 one package per exporter: gemara, oscal, sysml (metamodel/),
│   │                           structurizr, threatmodel, naf, trlc, lobster, airborne, exportutil
│   ├── integration/            test-only: end-to-end tests through the facade and across packages
│   ├── mcp/                    MCP server
│   ├── engws/                  engmod.work.yml workspace tool
│   ├── cliflags/               shared command-line flags
│   ├── sysmlmetamodel/         SysML v2 metamodel inventory tooling
│   ├── textutil/               shared string helpers
│   └── testutil/               shared test fixtures and helpers
├── engmod.yml, model/          this repository's own engineering model (YAML only)
├── generated/                  this repository's generated artifacts
├── examples/                   sample models with their generated outputs
├── docs/                       design notes and format guides
└── scripts/                    validation and tooling scripts (sysml-toolchain.env pins the SysML tools)

Package layering: imports point down only. textutil and model import nothing in the module; validate builds on model; codemap and view on those; render/* on view; composition on model, validate and textutil; codescan on composition and codemap; trace on codescan; reqlint on model and validate; reqdelta on reqlint and trace; generate on view, render/* and codescan; export/* on the layers below trace; asciidoc on all of these, never on mcp or engws. Only cmd/*, internal/mcp and internal/engws import the root facade (among tests, only internal/integration), and mcp and engws do not import each other. layering_test.go enforces the rules with go list.

The tests of the internal/... implementation packages run from the repository root (their TestMain changes to the directory holding go.mod), so they name repository paths such as examples/... and engmod.yml directly: go test ./internal/integration -run TestAtlasIndustriesCompanyExample.

Unit checks:

go test ./...
go vet ./...

The canonical validation gauntlet is scripts/validate-all.sh — the single source of truth for both local development and CI:

bash scripts/validate-all.sh

It runs strict gates that always fail the build:

go build ./...
generation gates: engdoc exits non-zero on any error (transitively enforcing trace integrity / dangling links, EARS lint, and composition checks)
engtrace: zero dangling code trace links per model
artifact freshness: regenerated ARCHITECTURE.adoc / DECISIONS.adoc / TRACE-MATRIX.json must match what is committed (detected via git diff)

plus best-effort gates that run only when their tool is on PATH (a missing tool is skipped, a real failure still fails the build):

Gemara CUE schema validation (cue)
Structurizr DSL validation (behind ENGMOD_VALIDATE_STRUCTURIZR=1, via docker/podman)
TRLC validation (trlc)

.github/workflows/ci.yml runs scripts/validate-all.sh, so the same gates apply in CI.

Generated ARCHITECTURE.adoc, DECISIONS.adoc, and TRACE-MATRIX.json are deterministic and reproducible; CI fails on any drift, so when you change a model you must regenerate these artifacts and commit them alongside the model change.

Contributing

See CONTRIBUTING.md.

License

This project is licensed under the MIT License. See LICENSE.

Documentation ¶

Overview ¶

ENGMODEL-OWNER-UNIT: FU-AIRBORNE-ASSURANCE-EXPORTER

ENGMODEL-OWNER-UNIT: FU-ASCIIDOC-GENERATOR

ENGMODEL-OWNER-UNIT: FU-SYSTEM-COMPOSITION

ENGMODEL-OWNER-UNIT: FU-GEMARA-EXPORTER

ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION

ENGMODEL-OWNER-UNIT: FU-LOBSTER-EXPORTER

ENGMODEL-OWNER-UNIT: FU-NAF-EXPORTER

ENGMODEL-OWNER-UNIT: FU-OSCAL-EXPORTER

ENGMODEL-OWNER-UNIT: FU-VALIDATION-ENGINE

ENGMODEL-OWNER-UNIT: FU-MODEL-CHANGE

ENGMODEL-OWNER-UNIT: FU-STRUCTURIZR-EXPORTER

ENGMODEL-OWNER-UNIT: FU-SYSML-EXPORTER

ENGMODEL-OWNER-UNIT: FU-THREAT-EXPORTER

ENGMODEL-OWNER-UNIT: FU-ALLOCATION-TRACE

ENGMODEL-OWNER-UNIT: FU-TRLC-EXPORTER

Package engmodel is the public Go API of engineering-model-go. Every other package of the module is internal; the types and functions listed here are the supported surface.

The API areas are:

Model: LoadBundle reads an engmod.yml manifest and its domain documents into a Bundle (Requirement, FunctionalUnit, Interface, Decision, CatalogEntry and the other document and entity types are aliases of the loader's types). LoadCanonicalBundle, NewCanonicalBundle and ProjectSemanticModel give the canonical semantic model; BuildAuthoringContract describes how to author it. LoadWorkspace, FindWorkspace and FindWorkspaceWith resolve engmod.work.yml workspaces.
Validation: ValidateBundle returns Diagnostic values; HasErrors, SortDiagnostics, DedupeDiagnostics and AuthoringRules work on them.
Composition: ResolveCompositionProjection and the Generate*Composition* functions resolve and render systems of systems across model modules.
Views and documents: Generate and GenerateFromFile project one view to Mermaid; GenerateAsciiDoc* renders the architecture document.
Trace: BuildTraceMatrixFromFiles links requirements, code and tests.
Exports: Structurizr DSL, SysML v2, NAF, TRLC, LOBSTER, Threat Dragon and Open Threat Model, Gemara, OSCAL and airborne assurance packages (the Generate*, Export* and Validate* functions named after each format).

The implementation lives in internal/... packages (internal/asciidoc for the publication, internal/export/<format> for the exporters, internal/trace, internal/composition and others); the files of this package are type aliases, constants and thin wrappers over them, grouped by area (model_api.go, validate_api.go, api_<area>.go).

The command-line tools under cmd/ are thin wrappers over this API.

ENGMODEL-OWNER-UNIT: FU-MODEL-LOADER

ENGMODEL-OWNER-UNIT: FU-VALIDATION-ENGINE

Index ¶

Constants
Variables
func BuildTraceMatrixFromFiles(modelPath, requirementsPath, codeRoot string) (TraceMatrix, []Diagnostic, error)
func BuildTraceMatrixFromFilesWith(modelPath, requirementsPath, codeRoot string, options TraceOptions) (TraceMatrix, []Diagnostic, error)
func CompareSysMLV2RoundTrip(expected, actual SemanticModel) []string
func GenerateGemaraOSCALAssessmentResults(bundle Bundle, requirements RequirementsDocument, codeRoot string, ...) (string, error)
func GenerateGemaraOSCALAssessmentResultsFromFiles(architecturePath, requirementsPath, codeRoot string, ...) (string, error)
func GenerateGemaraOSCALCatalog(bundle Bundle, options GemaraExportOptions) (string, error)
func GenerateGemaraOSCALCatalogFromFile(architecturePath string, options GemaraExportOptions) (string, error)
func GenerateOSCALProfile(bundle Bundle, options OSCALProfileOptions) (string, error)
func GenerateOSCALProfileFromFile(path string, options OSCALProfileOptions) (string, error)
func HasComposition(bundle Bundle) bool
func HasErrors(diags []Diagnostic) bool
func HasSemanticErrors(diagnostics []SemanticDiagnostic) bool
func ParseQualifiedReference(ref string) (alias, id string, err error)
func ProjectSemanticModel(bundle Bundle) (SemanticModel, []SemanticDiagnostic)
func QualifyReference(alias, id string) (string, error)
func ResolveCompositionProjection(bundle Bundle) (CompositionProjection, CompositionResult, error)
func ResolveCompositionProjectionWith(bundle Bundle, options ResolutionOptions) (CompositionProjection, CompositionResult, error)
func ValidateSysMLV2Coverage(manifest SysMLCoverageManifest) error
func WriteCompositionLock(path string, lock CompositionLockDocument) error
type Actor
type AirborneApproval
type AirborneAssuranceOptions
type AirborneAssuranceResult
- func GenerateAirborneAssuranceFromFile(manifestPath string, options AirborneAssuranceOptions) (AirborneAssuranceResult, error)
type AirborneProfile
type AirborneReview
type AirborneTool
type AirborneVerificationCase
type Allocation
type ArchitectureDocument
type AsciiDocOptions
type AsciiDocResult
- func GenerateAsciiDoc(bundle Bundle, requirements RequirementsDocument, design DesignDocument, ...) (AsciiDocResult, error)
- func GenerateAsciiDocFromFiles(architecturePath, requirementsPath, designPath string, options AsciiDocOptions) (AsciiDocResult, error)
type AssuranceDocument
type AssuranceModel
type AttackVector
type AuthoredArchitecture
type AuthoringContract
- func BuildAuthoringContract(bundle Bundle) AuthoringContract
type AuthoringDocument
type AviationDocument
type AviationProfile
type AviationValidationError
type BehaviorDocument
type BehaviorModel
type Bundle
- func LoadBundle(manifestPath string) (Bundle, error)
type CanonicalBundle
- func LoadCanonicalBundle(manifestPath string) (CanonicalBundle, error)
- func NewCanonicalBundle(bundle Bundle) (CanonicalBundle, error)
type CatalogDocument
type CatalogEntry
type CatalogGroups
type CertificationLiaison
type ComplianceDocument
type ComplianceMapping
type ComplianceModel
type ComplianceProfile
type ComposedSystem
type CompositionLockDependency
type CompositionLockDocument
type CompositionModel
type CompositionProjection
- func BuildCompositionProjection(result CompositionResult) CompositionProjection
type CompositionResult
- func GenerateCompositionForBundle(bundle Bundle, options ResolutionOptions) (CompositionResult, error)
- func GenerateCompositionFromFile(manifestPath string) (CompositionResult, error)
- func GenerateCompositionFromFileWith(manifestPath string, options ResolutionOptions) (CompositionResult, error)
type ConfigurationArtifact
type ConfigurationBaseline
type ConfigurationBuild
type ContractEntry
type ContractModel
type Control
type ControlEvidence
type ControlVerification
type ControlVerificationEvidence
type DanglingLink
type DataObject
type Decision
type DecisionsDocument
type DependencyGuide
type DeploymentTarget
type DesignDocument
- func LoadDesign(path string) (DesignDocument, error)
type DesignFunctionalGroup
type DesignFunctionalUnit
type DesignModel
type DesignView
type Diagnostic
- func DedupeDiagnostics(lists ...[]Diagnostic) []Diagnostic
- func QualifiedReferenceDiagnostics(bundle Bundle, result CompositionResult) []Diagnostic
- func SortDiagnostics(in []Diagnostic) []Diagnostic
- func SuppressWaivedDiagnostics(diags []Diagnostic, waivers map[string][]string) []Diagnostic
- func ValidateBundle(b Bundle) []Diagnostic
type DocumentControl
type DocumentDefinition
type DocumentReferences
type DocumentSection
type Event
type EvidenceReference
type Expected
type Flow
type FlowStep
type FunctionalGroup
type FunctionalUnit
type GemaraCrossReferenceError
- func CheckGemaraCrossReferences(docs map[string]string) []GemaraCrossReferenceError
- func CheckGemaraModelConsistency(bundle Bundle, docs map[string]string) []GemaraCrossReferenceError
type GemaraEvaluationResult
- func GenerateGemaraEvaluationLog(bundle Bundle, requirements RequirementsDocument, codeRoot string, ...) (GemaraEvaluationResult, error)
- func GenerateGemaraEvaluationLogFromFiles(architecturePath, requirementsPath, codeRoot string, ...) (GemaraEvaluationResult, error)
type GemaraExportOptions
type GemaraExportResult
- func GenerateGemara(bundle Bundle, options GemaraExportOptions) (GemaraExportResult, error)
- func GenerateGemaraFromFile(architecturePath string, options GemaraExportOptions) (GemaraExportResult, error)
type HardwareInterface
type HardwareItem
type ImportedEntityProvenance
type IndependenceRecord
type InferenceHints
type Interface
type LifecycleDataRecord
type LintRun
type LintWaiver
type LobsterActivityExportOptions
type LobsterActivityExportResult
- func GenerateLobsterActivityTraceFromDir(testsDir string, options LobsterActivityExportOptions) (LobsterActivityExportResult, error)
type ManifestDependency
type ManifestDocument
type ManifestPublication
type Mapping
type MaterializedAllocation
type MetamodelPropertyValue
type MetamodelValue
type ModelMeta
type ModuleIdentity
type Multiplicity
type NAFConcern
type NAFExportResult
- func GenerateNAFV41(bundle Bundle) (NAFExportResult, error)
- func GenerateNAFV41FromFile(architecturePath string) (NAFExportResult, error)
type NAFProduct
type NAFProfile
type NAFStakeholder
type OSCALAPDocument
type OSCALAPOptions
type OSCALAPResult
- func GenerateOSCALAssessmentPlan(bundle Bundle, options OSCALAPOptions) (OSCALAPResult, error)
- func GenerateOSCALAssessmentPlanFromFile(architecturePath string, options OSCALAPOptions) (OSCALAPResult, error)
type OSCALARDocument
type OSCALAROptions
type OSCALARResult
- func GenerateOSCALAssessmentResults(bundle Bundle, requirements RequirementsDocument, options OSCALAROptions) (OSCALARResult, error)
- func GenerateOSCALAssessmentResultsFromFile(architecturePath string, options OSCALAROptions) (OSCALARResult, error)
type OSCALPOAMDocument
type OSCALPOAMOptions
type OSCALPOAMResult
- func GenerateOSCALPOAM(bundle Bundle, options OSCALPOAMOptions) (OSCALPOAMResult, error)
- func GenerateOSCALPOAMFromFile(architecturePath string, options OSCALPOAMOptions) (OSCALPOAMResult, error)
type OSCALProfileOptions
type OSCALSSPDocument
type OSCALSSPOptions
type OSCALSSPResult
- func GenerateOSCALSSP(bundle Bundle, options OSCALSSPOptions) (OSCALSSPResult, error)
- func GenerateOSCALSSPFromFile(architecturePath string, options OSCALSSPOptions) (OSCALSSPResult, error)
type ObjectiveReference
type POAMArtifact
type POAMItem
type ProblemReport
type PublishedProjection
type PublishedProjectionEntity
type ReferencedElement
type RelationshipPair
type Requirement
type RequirementAssurance
type RequirementsDelta
type RequirementsDeltaOperations
type RequirementsDeltaResult
- func ApplyRequirementsDelta(root, deltaPath string) (result RequirementsDeltaResult, err error)
- func PlanRequirementsDelta(root, deltaPath string) (RequirementsDeltaResult, error)
type RequirementsDocument
- func LoadRequirements(path string) (RequirementsDocument, error)
type ResolutionOptions
type Result
- func Generate(bundle Bundle, viewID string) (Result, error)
- func GenerateFromFile(architecturePath, viewID string) (Result, error)
type Risk
type RiskEvidence
type SQAAudit
type Satisfaction
type SemanticContent
type SemanticDiagnostic
- func GenerateSysMLV2Projection(semantic SemanticModel) (string, []SemanticDiagnostic)
- func ValidateSemanticModel(semantic SemanticModel) []SemanticDiagnostic
type SemanticElement
type SemanticElementKind
type SemanticExpression
type SemanticFeature
type SemanticFeatureKind
type SemanticImport
type SemanticMetadata
type SemanticModel
- func ImportSysMLV2Project(sourcePath string) (SemanticModel, error)
type SemanticQuantity
type SemanticRelationship
type SemanticRelationshipKind
type SemanticSeverity
type SemanticValue
type Severity
type SpecDeltaOperation
type SpecDeltaOptions
type SpecDeltaResult
- func RenderSpecDelta(requirements []Requirement, options SpecDeltaOptions) (SpecDeltaResult, error)
- func RenderSpecDeltaFromModel(manifestPath string, options SpecDeltaOptions) (SpecDeltaResult, error)
type StableIdentifierGuide
type State
type StructuralCoverage
type StructurizrExportResult
- func GenerateStructurizrDSL(bundle Bundle) (StructurizrExportResult, error)
- func GenerateStructurizrDSLFromFile(architecturePath string) (StructurizrExportResult, error)
type Subsystem
type SysMLCoverageAuthority
type SysMLCoverageCheckEvidence
type SysMLCoverageManifest
- func SysMLV2Coverage() SysMLCoverageManifest
type SysMLCoverageTotals
type SysMLExportResult
- func ExportSysMLV2Project(architecturePath, projectDir, kparPath, sysandPath string) (SysMLExportResult, error)
- func GenerateSysMLV2(bundle Bundle) (SysMLExportResult, error)
- func GenerateSysMLV2FromFile(architecturePath string) (SysMLExportResult, error)
type SysMLExtensionCoverage
type SysMLMetaclassCoverage
type SysMLPropertyCoverage
type SysMLRelationshipCoverage
type SysMLRendererCoverage
type SysMLRendererEvidence
type SysMLRoundTripResult
- func ReopenSysMLV2Project(kparPath, reopenedDir, sysandPath string) (SysMLRoundTripResult, error)
- func VerifySysMLV2RoundTrip(architecturePath, kparPath, reopenedDir, sysandPath string) (SysMLRoundTripResult, error)
type TRLCExportOptions
type TRLCExportResult
- func GenerateTRLCRequirements(requirements RequirementsDocument, options TRLCExportOptions) (TRLCExportResult, error)
- func GenerateTRLCRequirementsFromFile(requirementsPath string, options TRLCExportOptions) (TRLCExportResult, error)
type ThreatAssumption
type ThreatAssumptionEvidence
type ThreatMitigation
type ThreatMitigationEvidence
type ThreatModelExportOptions
type ThreatModelExportResult
- func GenerateThreatModelExport(bundle Bundle, options ThreatModelExportOptions) (ThreatModelExportResult, error)
- func GenerateThreatModelExportFromFile(architecturePath string, options ThreatModelExportOptions) (ThreatModelExportResult, error)
type ThreatModelFormat
type ThreatOutOfScope
type ThreatOutOfScopeEvidence
type ThreatScenario
type ThreatScenarioEvidence
type ToolAssessment
type TraceCodeRef
type TraceDelegatedStatus
type TraceDelegation
type TraceMatrix
type TraceOptions
type TraceProvenance
type TraceRow
type TraceSummary
type TrustBoundary
type UncoveredDisposition
type ValidationRules
- func AuthoringRules() ValidationRules
type VerificationExecution
type VerificationProcedure
type View
type ViewsDocument
type WorkspaceDocument
- func FindWorkspace(start string) (WorkspaceDocument, string, error)
- func FindWorkspaceWith(start, mode string) (WorkspaceDocument, string, error)
- func LoadWorkspace(path string) (WorkspaceDocument, error)
type WorkspaceReplacement

Constants ¶

View Source

const (
	SpecDeltaAdded    = reqdelta.SpecDeltaAdded
	SpecDeltaModified = reqdelta.SpecDeltaModified
)

SpecDeltaAdded and SpecDeltaModified select "## ADDED Requirements" (default) or "## MODIFIED Requirements".

View Source

const (
	// CurrentSchemaVersion is the document schemaVersion this release reads.
	CurrentSchemaVersion = model.CurrentSchemaVersion
	// AuthoringContractVersion identifies the authoring contract format.
	AuthoringContractVersion = model.AuthoringContractVersion
	// WorkspaceFileName is the workspace file looked up from a model directory upwards.
	WorkspaceFileName = model.WorkspaceFileName
	// WorkspaceEnv names the environment variable that selects the workspace.
	WorkspaceEnv = model.WorkspaceEnv
	// WorkspaceOff is the workspace mode that disables workspace lookup.
	WorkspaceOff = model.WorkspaceOff
)

Model constants.

View Source

const (
	SeverityError   = validate.SeverityError
	SeverityWarning = validate.SeverityWarning
)

Diagnostic severities.

View Source

const AirborneDisclaimer = airborne.Disclaimer

View Source

const CompositionLocalLockFileName = composition.CompositionLocalLockFileName

CompositionLocalLockFileName receives the resolved lock while workspace replacements are active, so the committed lock never pins unpublished content.

View Source

const CompositionLockFileName = composition.CompositionLockFileName

View Source

const GemaraVersion = gemara.Version

GemaraVersion is the Gemara specification version stamped into every artifact's metadata.

View Source

const LockEnv = composition.LockEnv

LockEnv selects the lock mode: "check" compares with the committed lock and writes nothing; "write" (or unset) writes the lock.

View Source

const LockModeCheck = composition.LockModeCheck

LockModeCheck compares the resolved lock with engmod.lock.yml and writes nothing.

View Source

const LockModeWrite = composition.LockModeWrite

LockModeWrite writes engmod.lock.yml (or the local lock in workspace mode).

View Source

const ModuleCacheEnv = composition.ModuleCacheEnv

ModuleCacheEnv selects the module cache mode: "refresh" re-fetches every registry dependency; "reuse" reuses cached modules offline; unset applies the defaults of cacheMode.

View Source

const ModuleCacheRefresh = composition.ModuleCacheRefresh

ModuleCacheRefresh re-fetches every registry dependency.

View Source

const ModuleCacheReuse = composition.ModuleCacheReuse

ModuleCacheReuse reuses a cached module without contacting the registry. Set explicitly it applies in every lock mode; it is also the default except for lock check mode and lock regeneration (see cacheMode).

View Source

const ThreatModelFormatOpenOTM = threatmodel.FormatOpenOTM

View Source

const ThreatModelFormatThreatDragonV2 = threatmodel.FormatThreatDragonV2

Variables ¶

View Source

var ErrNoAviationProfile = airborne.ErrNoAviationProfile

View Source

var ErrNoLobsterActivities = lobster.ErrNoActivities

View Source

var ErrNoOSCALCompliance = oscal.ErrNoCompliance

View Source

var ErrNoOSCALProfiles = oscal.ErrNoProfiles

ErrNoOSCALProfiles indicates that the model has no compliance profile to publish as an aggregate OSCAL profile.

View Source

var ErrNoPOAMItems = oscal.ErrNoPOAMItems

Functions ¶

func BuildTraceMatrixFromFiles ¶

func BuildTraceMatrixFromFiles(modelPath, requirementsPath, codeRoot string) (TraceMatrix, []Diagnostic, error)

BuildTraceMatrixFromFiles loads a model, scans its code root, scopes the code to the model, validates trace integrity, and returns the matrix together with diagnostics. TRLC-LINKS: REQ-EMG-028, REQ-EMG-030, REQ-EMG-050, REQ-EMG-051 ENGMODEL-LINKS: FU-ALLOCATION-TRACE, FU-MODEL-LOADER, FU-CODEMAP-INFERENCE

func BuildTraceMatrixFromFilesWith ¶ added in v0.4.0

func BuildTraceMatrixFromFilesWith(modelPath, requirementsPath, codeRoot string, options TraceOptions) (TraceMatrix, []Diagnostic, error)

BuildTraceMatrixFromFilesWith is BuildTraceMatrixFromFiles with explicit resolution options. With composition it composes once, resolves code ENGMODEL-LINKS alias::ID against the dependencies' published entities (requirements stay local), returns the composition diagnostics, and reports each delegated requirement's own status in its target repository. TRLC-LINKS: REQ-EMG-028, REQ-EMG-030, REQ-EMG-050, REQ-EMG-051, REQ-EMG-065, REQ-EMG-066, REQ-EMG-067 ENGMODEL-LINKS: FU-ALLOCATION-TRACE, FU-MODEL-LOADER, FU-CODEMAP-INFERENCE, FU-SYSTEM-COMPOSITION

func CompareSysMLV2RoundTrip ¶ added in v0.2.0

func CompareSysMLV2RoundTrip(expected, actual SemanticModel) []string

CompareSysMLV2RoundTrip reports differences in stable identity, ownership, relationships, expressions, references, and typed extensions.

TRLC-LINKS: REQ-EMG-036, REQ-EMG-037

func GenerateGemaraOSCALAssessmentResults ¶

func GenerateGemaraOSCALAssessmentResults(bundle Bundle, requirements RequirementsDocument, codeRoot string, options GemaraExportOptions) (string, error)

GenerateGemaraOSCALAssessmentResults converts the Gemara Evaluation Log to OSCAL Assessment Results JSON via the go-gemara SDK. Returns "" when there is nothing to evaluate. TRLC-LINKS: REQ-EMG-015, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateGemaraOSCALAssessmentResultsFromFiles ¶

func GenerateGemaraOSCALAssessmentResultsFromFiles(architecturePath, requirementsPath, codeRoot string, options GemaraExportOptions) (string, error)

GenerateGemaraOSCALAssessmentResultsFromFiles loads inputs and emits OSCAL Assessment Results derived from the Gemara evaluation log. TRLC-LINKS: REQ-EMG-015 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateGemaraOSCALCatalog ¶

func GenerateGemaraOSCALCatalog(bundle Bundle, options GemaraExportOptions) (string, error)

GenerateGemaraOSCALCatalog converts the Gemara Control Catalog to an OSCAL Catalog JSON document via the go-gemara SDK. Returns "" when there are no controls. TRLC-LINKS: REQ-EMG-015, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateGemaraOSCALCatalogFromFile ¶

func GenerateGemaraOSCALCatalogFromFile(architecturePath string, options GemaraExportOptions) (string, error)

GenerateGemaraOSCALCatalogFromFile loads the model and emits an OSCAL Catalog derived from the Gemara Control Catalog. TRLC-LINKS: REQ-EMG-015 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateOSCALProfile ¶ added in v0.2.0

func GenerateOSCALProfile(bundle Bundle, options OSCALProfileOptions) (string, error)

GenerateOSCALProfile emits a deterministic OSCAL 1.1.2 aggregate profile so multi-framework SSPs import every framework they implement. TRLC-LINKS: REQ-EMG-013 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateOSCALProfileFromFile ¶ added in v0.2.0

func GenerateOSCALProfileFromFile(path string, options OSCALProfileOptions) (string, error)

GenerateOSCALProfileFromFile loads a model and emits one profile importing every authored compliance profile. TRLC-LINKS: REQ-EMG-013 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func HasComposition ¶

func HasComposition(bundle Bundle) bool

HasComposition reports whether the model declares any subsystems. TRLC-LINKS: REQ-EMG-016 ENGMODEL-LINKS: FU-SYSTEM-COMPOSITION

func HasErrors ¶ added in v0.5.0

func HasErrors(diags []Diagnostic) bool

HasErrors reports whether any diagnostic has SeverityError. ENGMODEL-LINKS: FU-VALIDATION-ENGINE, STATE-MODEL-VALID, STATE-MODEL-INVALID TRLC-LINKS: REQ-EMG-001, REQ-EMG-009, REQ-EMG-011

func HasSemanticErrors ¶ added in v0.5.0

func HasSemanticErrors(diagnostics []SemanticDiagnostic) bool

HasSemanticErrors reports whether any semantic diagnostic is an error. ENGMODEL-LINKS: FU-MODEL-LOADER, DO-CANONICAL-SEMANTIC-MODEL TRLC-LINKS: REQ-EMG-035, REQ-EMG-036

func ParseQualifiedReference ¶ added in v0.5.0

func ParseQualifiedReference(ref string) (alias, id string, err error)

ParseQualifiedReference splits an alias::ID reference. ENGMODEL-LINKS: FU-MODEL-LOADER, FU-SYSTEM-COMPOSITION TRLC-LINKS: REQ-EMG-049, REQ-EMG-051

func ProjectSemanticModel ¶ added in v0.5.0

func ProjectSemanticModel(bundle Bundle) (SemanticModel, []SemanticDiagnostic)

ProjectSemanticModel projects a bundle into the canonical semantic model and returns the projection diagnostics. ENGMODEL-LINKS: FU-MODEL-LOADER, DO-CANONICAL-SEMANTIC-MODEL, DO-ARCHITECTURE-MODEL TRLC-LINKS: REQ-EMG-035

func QualifyReference ¶ added in v0.5.0

func QualifyReference(alias, id string) (string, error)

QualifyReference joins a dependency alias and a local ID into alias::ID. ENGMODEL-LINKS: FU-MODEL-LOADER, FU-SYSTEM-COMPOSITION TRLC-LINKS: REQ-EMG-049, REQ-EMG-051

func ResolveCompositionProjection ¶ added in v0.2.0

func ResolveCompositionProjection(bundle Bundle) (CompositionProjection, CompositionResult, error)

ResolveCompositionProjection resolves and validates composition for a bundle. TRLC-LINKS: REQ-EMG-050, REQ-EMG-051

func ResolveCompositionProjectionWith ¶ added in v0.4.0

func ResolveCompositionProjectionWith(bundle Bundle, options ResolutionOptions) (CompositionProjection, CompositionResult, error)

ResolveCompositionProjectionWith is ResolveCompositionProjection under explicit workspace and lock modes. TRLC-LINKS: REQ-EMG-050, REQ-EMG-051, REQ-EMG-063, REQ-EMG-064

func ValidateSysMLV2Coverage ¶ added in v0.2.0

func ValidateSysMLV2Coverage(manifest SysMLCoverageManifest) error

ValidateSysMLV2Coverage rejects any gap or stale/tampered evidence.

TRLC-LINKS: REQ-EMG-039, REQ-EMG-040

func WriteCompositionLock ¶ added in v0.2.0

func WriteCompositionLock(path string, lock CompositionLockDocument) error

WriteCompositionLock writes deterministic generated dependency state. TRLC-LINKS: REQ-EMG-047, REQ-EMG-048, REQ-EMG-049, REQ-EMG-051

Types ¶

type Actor ¶ added in v0.5.0

type Actor = model.Actor

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AirborneApproval ¶ added in v0.5.0

type AirborneApproval = model.AirborneApproval

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AirborneAssuranceOptions ¶ added in v0.2.0

type AirborneAssuranceOptions = airborne.Options

type AirborneAssuranceResult ¶ added in v0.2.0

type AirborneAssuranceResult = airborne.Result

func GenerateAirborneAssuranceFromFile ¶ added in v0.2.0

func GenerateAirborneAssuranceFromFile(manifestPath string, options AirborneAssuranceOptions) (AirborneAssuranceResult, error)

GenerateAirborneAssuranceFromFile validates and renders the complete evidence-readiness package. It does not determine compliance or certification. TRLC-LINKS: REQ-EMG-053, REQ-EMG-054, REQ-EMG-055

type AirborneProfile ¶ added in v0.5.0

type AirborneProfile = model.AirborneProfile

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AirborneReview ¶ added in v0.5.0

type AirborneReview = model.AirborneReview

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AirborneTool ¶ added in v0.5.0

type AirborneTool = model.AirborneTool

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AirborneVerificationCase ¶ added in v0.5.0

type AirborneVerificationCase = model.AirborneVerificationCase

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Allocation ¶ added in v0.5.0

type Allocation = model.Allocation

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ArchitectureDocument ¶ added in v0.5.0

type ArchitectureDocument = model.ArchitectureDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AsciiDocOptions ¶

type AsciiDocOptions = asciidoc.Options

ENGMODEL-LINKS: FU-ASCIIDOC-GENERATOR, FU-CODEMAP-INFERENCE, CTRL-TRACEABILITY-COVERAGE, DEP-LOCAL-WORKSPACE

type AsciiDocResult ¶

type AsciiDocResult = asciidoc.Result

ENGMODEL-LINKS: FU-ASCIIDOC-GENERATOR, FU-VALIDATION-ENGINE, CTRL-TRACEABILITY-COVERAGE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateAsciiDoc ¶

func GenerateAsciiDoc(bundle Bundle, requirements RequirementsDocument, design DesignDocument, options AsciiDocOptions) (AsciiDocResult, error)

GenerateAsciiDoc validates and renders the model. With composition it resolves the dependencies once, validates against the bundle enriched with their published entities, and returns every composition diagnostic; a composition error fails the call like any other validation error. ENGMODEL-LINKS: FU-ASCIIDOC-GENERATOR, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS TRLC-LINKS: REQ-EMG-001, REQ-EMG-003, REQ-EMG-014, REQ-EMG-035, REQ-EMG-036, REQ-EMG-065, REQ-EMG-066

func GenerateAsciiDocFromFiles ¶

func GenerateAsciiDocFromFiles(architecturePath, requirementsPath, designPath string, options AsciiDocOptions) (AsciiDocResult, error)

ENGMODEL-LINKS: FU-ASCIIDOC-GENERATOR, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS TRLC-LINKS: REQ-EMG-001, REQ-EMG-003, REQ-EMG-014

type AssuranceDocument ¶ added in v0.5.0

type AssuranceDocument = model.AssuranceDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AssuranceModel ¶ added in v0.5.0

type AssuranceModel = model.AssuranceModel

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AttackVector ¶ added in v0.5.0

type AttackVector = model.AttackVector

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AuthoredArchitecture ¶ added in v0.5.0

type AuthoredArchitecture = model.AuthoredArchitecture

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AuthoringContract ¶ added in v0.5.0

type AuthoringContract = model.AuthoringContract

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

func BuildAuthoringContract ¶ added in v0.5.0

func BuildAuthoringContract(bundle Bundle) AuthoringContract

BuildAuthoringContract describes the documents, schemas, identifiers and dependency rules an author or agent needs to edit the model. ENGMODEL-LINKS: FU-MODEL-LOADER, DO-MODEL-AUTHORING-CONTRACT TRLC-LINKS: REQ-EMG-044, REQ-EMG-045, REQ-EMG-047, REQ-EMG-048, REQ-EMG-049, REQ-EMG-053

type AuthoringDocument ¶ added in v0.5.0

type AuthoringDocument = model.AuthoringDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AviationDocument ¶ added in v0.5.0

type AviationDocument = model.AviationDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AviationProfile ¶ added in v0.5.0

type AviationProfile = model.AviationProfile

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type AviationValidationError ¶ added in v0.5.0

type AviationValidationError = model.AviationValidationError

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type BehaviorDocument ¶ added in v0.5.0

type BehaviorDocument = model.BehaviorDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type BehaviorModel ¶ added in v0.5.0

type BehaviorModel = model.BehaviorModel

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Bundle ¶ added in v0.5.0

type Bundle = model.Bundle

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

func LoadBundle ¶ added in v0.5.0

func LoadBundle(manifestPath string) (Bundle, error)

LoadBundle reads the engmod.yml manifest at manifestPath and every domain document it names, validated against the canonical CUE schema. ENGMODEL-LINKS: FU-MODEL-LOADER, DO-ARCHITECTURE-MODEL TRLC-LINKS: REQ-EMG-001, REQ-EMG-044, REQ-EMG-046, REQ-EMG-049, REQ-EMG-051, REQ-EMG-053, REQ-EMG-054

type CanonicalBundle ¶ added in v0.5.0

type CanonicalBundle = model.CanonicalBundle

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

func LoadCanonicalBundle ¶ added in v0.5.0

func LoadCanonicalBundle(manifestPath string) (CanonicalBundle, error)

LoadCanonicalBundle loads the manifest at manifestPath and projects it into the canonical semantic model; projection errors are returned as an error. ENGMODEL-LINKS: FU-MODEL-LOADER, DO-CANONICAL-SEMANTIC-MODEL TRLC-LINKS: REQ-EMG-035, REQ-EMG-036, REQ-EMG-044, REQ-EMG-046

func NewCanonicalBundle ¶ added in v0.5.0

func NewCanonicalBundle(bundle Bundle) (CanonicalBundle, error)

NewCanonicalBundle projects an already loaded bundle into the canonical semantic model. ENGMODEL-LINKS: FU-MODEL-LOADER, DO-CANONICAL-SEMANTIC-MODEL TRLC-LINKS: REQ-EMG-035, REQ-EMG-036

type CatalogDocument ¶ added in v0.5.0

type CatalogDocument = model.CatalogDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type CatalogEntry ¶ added in v0.5.0

type CatalogEntry = model.CatalogEntry

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type CatalogGroups ¶ added in v0.5.0

type CatalogGroups = model.CatalogGroups

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type CertificationLiaison ¶ added in v0.5.0

type CertificationLiaison = model.CertificationLiaison

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ComplianceDocument ¶ added in v0.5.0

type ComplianceDocument = model.ComplianceDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ComplianceMapping ¶ added in v0.5.0

type ComplianceMapping = model.ComplianceMapping

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ComplianceModel ¶ added in v0.5.0

type ComplianceModel = model.ComplianceModel

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ComplianceProfile ¶ added in v0.5.0

type ComplianceProfile = model.ComplianceProfile

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ComposedSystem ¶

type ComposedSystem = composition.ComposedSystem

ComposedSystem is a resolved system together with its resolved subsystems. ENGMODEL-LINKS: FU-SYSTEM-COMPOSITION, DO-ARCHITECTURE-MODEL

type CompositionLockDependency ¶ added in v0.2.0

type CompositionLockDependency = composition.CompositionLockDependency

type CompositionLockDocument ¶ added in v0.2.0

type CompositionLockDocument = composition.CompositionLockDocument

CompositionLockDocument is deterministic generated dependency state. TRLC-LINKS: REQ-EMG-047, REQ-EMG-048, REQ-EMG-049, REQ-EMG-051

type CompositionModel ¶ added in v0.5.0

type CompositionModel = model.CompositionModel

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type CompositionProjection ¶ added in v0.2.0

type CompositionProjection = composition.CompositionProjection

CompositionProjection is the reusable, read-only projection boundary used by every output format. It never mutates an authored bundle. TRLC-LINKS: REQ-EMG-050, REQ-EMG-051

func BuildCompositionProjection ¶ added in v0.2.0

func BuildCompositionProjection(result CompositionResult) CompositionProjection

BuildCompositionProjection materializes only direct, explicitly selected dependency publications. Transitive or unexported child data is not exposed. TRLC-LINKS: REQ-EMG-050, REQ-EMG-051

type CompositionResult ¶

type CompositionResult = composition.CompositionResult

CompositionResult is the resolved tree plus materialized allocation trace and diagnostics. ENGMODEL-LINKS: FU-SYSTEM-COMPOSITION, FU-ALLOCATION-TRACE

func GenerateCompositionForBundle ¶ added in v0.4.0

func GenerateCompositionForBundle(bundle Bundle, options ResolutionOptions) (CompositionResult, error)

GenerateCompositionForBundle resolves the composition of an already loaded bundle: the dependencies are resolved from bundle.ManifestPath's location (workspace, module cache, lock) as in GenerateCompositionFromFileWith, but the root system - its manifest dependencies, composition, contract and every alias::ID reference - is the given bundle, not the files on disk. A caller validating edited content in memory thus gets the diagnostics of that content. TRLC-LINKS: REQ-EMG-065, REQ-EMG-066, REQ-EMG-069 ENGMODEL-LINKS: FU-SYSTEM-COMPOSITION, FU-MODEL-LOADER

func GenerateCompositionFromFile ¶

func GenerateCompositionFromFile(manifestPath string) (CompositionResult, error)

GenerateCompositionFromFile resolves the system-of-systems rooted at engmod.yml with the workspace and lock modes taken from ENGMOD_WORK and ENGMOD_LOCK. TRLC-LINKS: REQ-EMG-016, REQ-EMG-047, REQ-EMG-048, REQ-EMG-049, REQ-EMG-051, REQ-EMG-063, REQ-EMG-064 ENGMODEL-LINKS: FU-SYSTEM-COMPOSITION, FU-MODEL-LOADER, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

func GenerateCompositionFromFileWith ¶ added in v0.4.0

func GenerateCompositionFromFileWith(manifestPath string, options ResolutionOptions) (CompositionResult, error)

GenerateCompositionFromFileWith resolves the system-of-systems rooted at engmod.yml under explicit workspace and lock modes. Lock policy: while workspace replacements are active, engmod.lock.yml is never touched and the resolved lock is written to engmod.lock.local.yml; in check mode nothing is written and, without replacements, the resolved lock is compared with the committed one (composition.lock_missing, lock_invalid, lock_mismatch); otherwise engmod.lock.yml is written. TRLC-LINKS: REQ-EMG-016, REQ-EMG-047, REQ-EMG-048, REQ-EMG-049, REQ-EMG-051, REQ-EMG-063, REQ-EMG-064, REQ-EMG-066 ENGMODEL-LINKS: FU-SYSTEM-COMPOSITION, FU-MODEL-LOADER, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

type ConfigurationArtifact ¶ added in v0.5.0

type ConfigurationArtifact = model.ConfigurationArtifact

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ConfigurationBaseline ¶ added in v0.5.0

type ConfigurationBaseline = model.ConfigurationBaseline

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ConfigurationBuild ¶ added in v0.5.0

type ConfigurationBuild = model.ConfigurationBuild

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ContractEntry ¶ added in v0.5.0

type ContractEntry = model.ContractEntry

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ContractModel ¶ added in v0.5.0

type ContractModel = model.ContractModel

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Control ¶ added in v0.5.0

type Control = model.Control

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ControlEvidence ¶ added in v0.5.0

type ControlEvidence = model.ControlEvidence

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ControlVerification ¶ added in v0.5.0

type ControlVerification = model.ControlVerification

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ControlVerificationEvidence ¶ added in v0.5.0

type ControlVerificationEvidence = model.ControlVerificationEvidence

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DanglingLink ¶

type DanglingLink = trace.DanglingLink

DanglingLink is a code trace link that resolves to nothing in the model. ENGMODEL-LINKS: FU-VALIDATION-ENGINE, CTRL-TRACEABILITY-COVERAGE

type DataObject ¶ added in v0.5.0

type DataObject = model.DataObject

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Decision ¶ added in v0.5.0

type Decision = model.Decision

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DecisionsDocument ¶ added in v0.5.0

type DecisionsDocument = model.DecisionsDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DependencyGuide ¶ added in v0.5.0

type DependencyGuide = model.DependencyGuide

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DeploymentTarget ¶ added in v0.5.0

type DeploymentTarget = model.DeploymentTarget

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DesignDocument ¶ added in v0.5.0

type DesignDocument = model.DesignDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

func LoadDesign ¶ added in v0.5.0

func LoadDesign(path string) (DesignDocument, error)

LoadDesign reads a single design document. ENGMODEL-LINKS: FU-MODEL-LOADER, DO-ARCHITECTURE-MODEL TRLC-LINKS: REQ-EMG-001, REQ-EMG-044, REQ-EMG-046

type DesignFunctionalGroup ¶ added in v0.5.0

type DesignFunctionalGroup = model.DesignFunctionalGroup

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DesignFunctionalUnit ¶ added in v0.5.0

type DesignFunctionalUnit = model.DesignFunctionalUnit

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DesignModel ¶ added in v0.5.0

type DesignModel = model.DesignModel

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DesignView ¶ added in v0.5.0

type DesignView = model.DesignView

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Diagnostic ¶ added in v0.5.0

type Diagnostic = validate.Diagnostic

Diagnostic is one validation finding with a stable code, severity, message and model path.

func DedupeDiagnostics ¶ added in v0.5.0

func DedupeDiagnostics(lists ...[]Diagnostic) []Diagnostic

DedupeDiagnostics merges diagnostic lists from separate checks of one run so each finding (code, path, message) is reported once; an error severity on a duplicate wins over a warning. ENGMODEL-LINKS: FU-VALIDATION-ENGINE, EVT-VALIDATION-FAILED TRLC-LINKS: REQ-EMG-001, REQ-EMG-009, REQ-EMG-011

func QualifiedReferenceDiagnostics ¶ added in v0.4.0

func QualifiedReferenceDiagnostics(bundle Bundle, result CompositionResult) []Diagnostic

QualifiedReferenceDiagnostics reports every alias::ID reference in the authored model that no selected dependency publication makes visible, once per field path (composition.unpublished_reference). A model without composition has no visible imports, so each of its qualified references is reported. TRLC-LINKS: REQ-EMG-065 ENGMODEL-LINKS: FU-SYSTEM-COMPOSITION, FU-VALIDATION-ENGINE

func SortDiagnostics ¶ added in v0.5.0

func SortDiagnostics(in []Diagnostic) []Diagnostic

SortDiagnostics returns a copy of in in stable path, severity, code and message order. ENGMODEL-LINKS: FU-VALIDATION-ENGINE TRLC-LINKS: REQ-EMG-001, REQ-EMG-009, REQ-EMG-011, REQ-EMG-012

func SuppressWaivedDiagnostics ¶ added in v0.4.0

func SuppressWaivedDiagnostics(diags []Diagnostic, waivers map[string][]string) []Diagnostic

SuppressWaivedDiagnostics removes requirement-scoped diagnostics a model has explicitly waived. waivers maps a requirement id to the diagnostic codes waived for it (for example "lint.multiple_responses"). Only warnings are suppressed: an error is never waived. Diagnostics whose path is not a requirement path are kept. ENGMODEL-LINKS: FU-VALIDATION-ENGINE, CTRL-TRACEABILITY-COVERAGE, STATE-MODEL-VALID, STATE-MODEL-INVALID TRLC-LINKS: REQ-EMG-001, REQ-EMG-009

func ValidateBundle ¶ added in v0.5.0

func ValidateBundle(b Bundle) []Diagnostic

ValidateBundle runs every model validation rule over a loaded bundle and returns the diagnostics. It is validate.Bundle, renamed because Bundle is the model type at the package root. ENGMODEL-LINKS: FU-VALIDATION-ENGINE, STATE-MODEL-VALID, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED TRLC-LINKS: REQ-EMG-001, REQ-EMG-009, REQ-EMG-011, REQ-EMG-035, REQ-EMG-036, REQ-EMG-037, REQ-EMG-041, REQ-EMG-043, REQ-EMG-049, REQ-EMG-065

type DocumentControl ¶ added in v0.5.0

type DocumentControl = model.DocumentControl

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DocumentDefinition ¶ added in v0.5.0

type DocumentDefinition = model.DocumentDefinition

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DocumentReferences ¶ added in v0.5.0

type DocumentReferences = model.DocumentReferences

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type DocumentSection ¶ added in v0.5.0

type DocumentSection = model.DocumentSection

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Event ¶ added in v0.5.0

type Event = model.Event

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type EvidenceReference ¶ added in v0.5.0

type EvidenceReference = model.EvidenceReference

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Expected ¶ added in v0.5.0

type Expected = model.Expected

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Flow ¶ added in v0.5.0

type Flow = model.Flow

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type FlowStep ¶ added in v0.5.0

type FlowStep = model.FlowStep

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type FunctionalGroup ¶ added in v0.5.0

type FunctionalGroup = model.FunctionalGroup

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type FunctionalUnit ¶ added in v0.5.0

type FunctionalUnit = model.FunctionalUnit

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type GemaraCrossReferenceError ¶ added in v0.4.0

type GemaraCrossReferenceError = gemara.CrossReferenceError

GemaraCrossReferenceError reports one reference that does not resolve within the rendered artifact set. ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func CheckGemaraCrossReferences ¶ added in v0.4.0

func CheckGemaraCrossReferences(docs map[string]string) []GemaraCrossReferenceError

CheckGemaraCrossReferences parses the artifacts (short-name -> YAML) and returns every EntryMapping, MultiEntryMapping, artifact import and mapping document source/target that does not resolve within the set. Documents that fail to parse are reported as errors too. TRLC-LINKS: REQ-EMG-015 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func CheckGemaraModelConsistency ¶ added in v0.4.0

func CheckGemaraModelConsistency(bundle Bundle, docs map[string]string) []GemaraCrossReferenceError

CheckGemaraModelConsistency compares the treatment claims in a rendered artifact set (short-name -> YAML) with the model they were rendered from: an enforcement action's disposition must follow its POA&M item's status (only completed is Enforced, only accepted is Tolerated), the log's aggregate must follow the actions, the policy may list a risk as mitigated only when it is closed and as accepted only when it is accepted. It reports each claim the model does not support with the same error shape as the cross-reference check. TRLC-LINKS: REQ-EMG-015, REQ-EMG-062 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type GemaraEvaluationResult ¶

type GemaraEvaluationResult = gemara.EvaluationResult

GemaraEvaluationResult holds the L5 Evaluation Log and its serialization. ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateGemaraEvaluationLog ¶

func GenerateGemaraEvaluationLog(bundle Bundle, requirements RequirementsDocument, codeRoot string, options GemaraExportOptions) (GemaraEvaluationResult, error)

GenerateGemaraEvaluationLog builds an L5 Evaluation Log from the model bundle. requirements and codeRoot are reserved for inferred-verification augmentation. TRLC-LINKS: REQ-EMG-015, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateGemaraEvaluationLogFromFiles ¶

func GenerateGemaraEvaluationLogFromFiles(architecturePath, requirementsPath, codeRoot string, options GemaraExportOptions) (GemaraEvaluationResult, error)

GenerateGemaraEvaluationLogFromFiles loads inputs and renders the Evaluation Log. TRLC-LINKS: REQ-EMG-015 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type GemaraExportOptions ¶

type GemaraExportOptions = gemara.Options

GemaraExportOptions configures the deterministic metadata stamped into artifacts. ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type GemaraExportResult ¶

type GemaraExportResult = gemara.Result

GemaraExportResult holds the typed Gemara documents and their YAML serializations. ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateGemara ¶

func GenerateGemara(bundle Bundle, options GemaraExportOptions) (GemaraExportResult, error)

GenerateGemara renders the engineering model bundle into Gemara L1-L3 documents. TRLC-LINKS: REQ-EMG-015, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateGemaraFromFile ¶

func GenerateGemaraFromFile(architecturePath string, options GemaraExportOptions) (GemaraExportResult, error)

GenerateGemaraFromFile loads the model bundle and renders the Gemara catalogs. TRLC-LINKS: REQ-EMG-015 ENGMODEL-LINKS: FU-GEMARA-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type HardwareInterface ¶ added in v0.5.0

type HardwareInterface = model.HardwareInterface

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type HardwareItem ¶ added in v0.5.0

type HardwareItem = model.HardwareItem

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ImportedEntityProvenance ¶ added in v0.2.0

type ImportedEntityProvenance = composition.ImportedEntityProvenance

ImportedEntityProvenance records where each visible imported identifier came from without leaking composition metadata into generic target properties. TRLC-LINKS: REQ-EMG-047, REQ-EMG-049, REQ-EMG-051

type IndependenceRecord ¶ added in v0.5.0

type IndependenceRecord = model.IndependenceRecord

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type InferenceHints ¶ added in v0.5.0

type InferenceHints = model.InferenceHints

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Interface ¶ added in v0.5.0

type Interface = model.Interface

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type LifecycleDataRecord ¶ added in v0.5.0

type LifecycleDataRecord = model.LifecycleDataRecord

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type LintRun ¶ added in v0.5.0

type LintRun = model.LintRun

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type LintWaiver ¶ added in v0.5.0

type LintWaiver = model.LintWaiver

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type LobsterActivityExportOptions ¶

type LobsterActivityExportOptions = lobster.Options

ENGMODEL-LINKS: FU-LOBSTER-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FU-TRLC-EXPORTER

type LobsterActivityExportResult ¶

type LobsterActivityExportResult = lobster.Result

ENGMODEL-LINKS: FU-LOBSTER-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateLobsterActivityTraceFromDir ¶

func GenerateLobsterActivityTraceFromDir(testsDir string, options LobsterActivityExportOptions) (LobsterActivityExportResult, error)

TRLC-LINKS: REQ-EMG-006, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-LOBSTER-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS, FU-TRLC-EXPORTER, FU-CODEMAP-INFERENCE, DEP-LOCAL-WORKSPACE

type ManifestDependency ¶ added in v0.5.0

type ManifestDependency = model.ManifestDependency

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ManifestDocument ¶ added in v0.5.0

type ManifestDocument = model.ManifestDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ManifestPublication ¶ added in v0.5.0

type ManifestPublication = model.ManifestPublication

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Mapping ¶ added in v0.5.0

type Mapping = model.Mapping

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type MaterializedAllocation ¶

type MaterializedAllocation = composition.MaterializedAllocation

MaterializedAllocation is a parent->subsystem allocation with its composed-view resolution status. ENGMODEL-LINKS: FU-ALLOCATION-TRACE, CTRL-TRACEABILITY-COVERAGE

type MetamodelPropertyValue ¶ added in v0.5.0

type MetamodelPropertyValue = model.MetamodelPropertyValue

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type MetamodelValue ¶ added in v0.5.0

type MetamodelValue = model.MetamodelValue

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ModelMeta ¶ added in v0.5.0

type ModelMeta = model.ModelMeta

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ModuleIdentity ¶ added in v0.5.0

type ModuleIdentity = model.ModuleIdentity

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Multiplicity ¶ added in v0.5.0

type Multiplicity = model.Multiplicity

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type NAFConcern ¶ added in v0.5.0

type NAFConcern = model.NAFConcern

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type NAFExportResult ¶ added in v0.2.0

type NAFExportResult = naf.Result

NAFExportResult is a deterministic NAF v4.1 architecture document and its diagnostics.

func GenerateNAFV41 ¶ added in v0.2.0

func GenerateNAFV41(bundle Bundle) (NAFExportResult, error)

GenerateNAFV41 validates and projects existing Engmod views into NAF products. TRLC-LINKS: REQ-EMG-041, REQ-EMG-042, REQ-EMG-043

func GenerateNAFV41FromFile ¶ added in v0.2.0

func GenerateNAFV41FromFile(architecturePath string) (NAFExportResult, error)

GenerateNAFV41FromFile loads canonical YAML and generates the selected NAF products. TRLC-LINKS: REQ-EMG-041, REQ-EMG-042, REQ-EMG-043 ENGMODEL-LINKS: FU-NAF-EXPORTER, IF-CLI-ENGNAF, DO-NAF-V4-ARCHITECTURE, REF-NAF-V4-1-SPECIFICATION

type NAFProduct ¶ added in v0.5.0

type NAFProduct = model.NAFProduct

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type NAFProfile ¶ added in v0.5.0

type NAFProfile = model.NAFProfile

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type NAFStakeholder ¶ added in v0.5.0

type NAFStakeholder = model.NAFStakeholder

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type OSCALAPDocument ¶ added in v0.2.0

type OSCALAPDocument = oscal.APDocument

type OSCALAPOptions ¶ added in v0.2.0

type OSCALAPOptions = oscal.APOptions

type OSCALAPResult ¶ added in v0.2.0

type OSCALAPResult = oscal.APResult

func GenerateOSCALAssessmentPlan ¶ added in v0.2.0

func GenerateOSCALAssessmentPlan(bundle Bundle, options OSCALAPOptions) (OSCALAPResult, error)

TRLC-LINKS: REQ-EMG-012, REQ-EMG-013 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FU-VALIDATION-ENGINE

func GenerateOSCALAssessmentPlanFromFile ¶ added in v0.2.0

func GenerateOSCALAssessmentPlanFromFile(architecturePath string, options OSCALAPOptions) (OSCALAPResult, error)

TRLC-LINKS: REQ-EMG-012, REQ-EMG-013 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

type OSCALARDocument ¶

type OSCALARDocument = oscal.ARDocument

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type OSCALAROptions ¶

type OSCALAROptions = oscal.AROptions

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type OSCALARResult ¶

type OSCALARResult = oscal.ARResult

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FU-VALIDATION-ENGINE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateOSCALAssessmentResults ¶

func GenerateOSCALAssessmentResults(bundle Bundle, requirements RequirementsDocument, options OSCALAROptions) (OSCALARResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-013, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS, FU-THREAT-EXPORTER, FU-VALIDATION-ENGINE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateOSCALAssessmentResultsFromFile ¶

func GenerateOSCALAssessmentResultsFromFile(architecturePath string, options OSCALAROptions) (OSCALARResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-013 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

type OSCALPOAMDocument ¶

type OSCALPOAMDocument = oscal.POAMDocument

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type OSCALPOAMOptions ¶

type OSCALPOAMOptions = oscal.POAMOptions

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type OSCALPOAMResult ¶

type OSCALPOAMResult = oscal.POAMResult

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FU-VALIDATION-ENGINE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateOSCALPOAM ¶

func GenerateOSCALPOAM(bundle Bundle, options OSCALPOAMOptions) (OSCALPOAMResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-013, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS, FU-THREAT-EXPORTER, FU-VALIDATION-ENGINE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateOSCALPOAMFromFile ¶

func GenerateOSCALPOAMFromFile(architecturePath string, options OSCALPOAMOptions) (OSCALPOAMResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-013 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

type OSCALProfileOptions ¶ added in v0.2.0

type OSCALProfileOptions = oscal.ProfileOptions

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type OSCALSSPDocument ¶

type OSCALSSPDocument = oscal.SSPDocument

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type OSCALSSPOptions ¶

type OSCALSSPOptions = oscal.SSPOptions

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type OSCALSSPResult ¶

type OSCALSSPResult = oscal.SSPResult

ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FU-VALIDATION-ENGINE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateOSCALSSP ¶

func GenerateOSCALSSP(bundle Bundle, options OSCALSSPOptions) (OSCALSSPResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-013, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS, FU-VALIDATION-ENGINE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateOSCALSSPFromFile ¶

func GenerateOSCALSSPFromFile(architecturePath string, options OSCALSSPOptions) (OSCALSSPResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-013 ENGMODEL-LINKS: FU-OSCAL-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

type ObjectiveReference ¶ added in v0.5.0

type ObjectiveReference = model.ObjectiveReference

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type POAMArtifact ¶ added in v0.5.0

type POAMArtifact = model.POAMArtifact

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type POAMItem ¶ added in v0.5.0

type POAMItem = model.POAMItem

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ProblemReport ¶ added in v0.5.0

type ProblemReport = model.ProblemReport

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type PublishedProjection ¶ added in v0.2.0

type PublishedProjection = composition.PublishedProjection

PublishedProjection groups the entities selected from one dependency publication. TRLC-LINKS: REQ-EMG-050, REQ-EMG-051

type PublishedProjectionEntity ¶ added in v0.2.0

type PublishedProjectionEntity = composition.PublishedProjectionEntity

PublishedProjectionEntity is one explicitly published dependency entity, retaining its typed value, qualified identity, source bundle, and provenance. TRLC-LINKS: REQ-EMG-050, REQ-EMG-051

type ReferencedElement ¶ added in v0.5.0

type ReferencedElement = model.ReferencedElement

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type RelationshipPair ¶ added in v0.5.0

type RelationshipPair = validate.RelationshipPair

RelationshipPair is one allowed mapping type with its end kinds.

type Requirement ¶ added in v0.5.0

type Requirement = model.Requirement

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type RequirementAssurance ¶ added in v0.5.0

type RequirementAssurance = model.RequirementAssurance

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type RequirementsDelta ¶

type RequirementsDelta = reqdelta.RequirementsDelta

RequirementsDelta describes stable-ID operations against requirements.yml. Updates replace the complete requirement entity. ENGMODEL-LINKS: FU-MODEL-CHANGE, DO-REQUIREMENTS-DELTA, DO-REQUIREMENTS-DOCUMENT

type RequirementsDeltaOperations ¶

type RequirementsDeltaOperations = reqdelta.RequirementsDeltaOperations

RequirementsDeltaOperations groups supported requirement mutations. ENGMODEL-LINKS: FU-MODEL-CHANGE, DO-REQUIREMENTS-DELTA

type RequirementsDeltaResult ¶

type RequirementsDeltaResult = reqdelta.RequirementsDeltaResult

RequirementsDeltaResult is the validated candidate and deterministic change summary. ENGMODEL-LINKS: FU-MODEL-CHANGE, FU-VALIDATION-ENGINE, DO-REQUIREMENTS-DELTA, DO-REQUIREMENTS-DOCUMENT

func ApplyRequirementsDelta ¶

func ApplyRequirementsDelta(root, deltaPath string) (result RequirementsDeltaResult, err error)

ApplyRequirementsDelta validates and atomically writes a requirements delta. TRLC-LINKS: REQ-EMG-031, REQ-EMG-032, REQ-EMG-033 ENGMODEL-LINKS: FU-MODEL-CHANGE, FU-MODEL-LOADER, FU-VALIDATION-ENGINE, DO-REQUIREMENTS-DELTA, DO-REQUIREMENTS-DOCUMENT, DEP-LOCAL-WORKSPACE

func PlanRequirementsDelta ¶

func PlanRequirementsDelta(root, deltaPath string) (RequirementsDeltaResult, error)

PlanRequirementsDelta loads a delta, applies it in memory, and validates the complete candidate. It never modifies requirements.yml. TRLC-LINKS: REQ-EMG-031, REQ-EMG-032 ENGMODEL-LINKS: FU-MODEL-CHANGE, FU-MODEL-LOADER, FU-VALIDATION-ENGINE, DO-REQUIREMENTS-DELTA, DO-REQUIREMENTS-DOCUMENT

type RequirementsDocument ¶ added in v0.5.0

type RequirementsDocument = model.RequirementsDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

func LoadRequirements ¶ added in v0.5.0

func LoadRequirements(path string) (RequirementsDocument, error)

LoadRequirements reads a single requirements document. ENGMODEL-LINKS: FU-MODEL-LOADER, DO-ARCHITECTURE-MODEL TRLC-LINKS: REQ-EMG-001, REQ-EMG-044, REQ-EMG-046

type ResolutionOptions ¶ added in v0.4.0

type ResolutionOptions = composition.ResolutionOptions

ResolutionOptions overrides the ENGMOD_WORK and ENGMOD_LOCK environment for one call. Empty fields fall back to the environment. Workspace is "off" or a workspace file path; Lock is "check" or "write". TRLC-LINKS: REQ-EMG-063, REQ-EMG-064

type Result ¶

type Result = generate.Result

ENGMODEL-LINKS: FU-CLI-ORCHESTRATION, FU-VIEW-PROJECTION, FU-ASCIIDOC-GENERATOR, FU-VALIDATION-ENGINE, CTRL-TRACEABILITY-COVERAGE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func Generate ¶

func Generate(bundle Bundle, viewID string) (Result, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-003, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS, FU-CLI-ORCHESTRATION, FU-VIEW-PROJECTION, FU-ASCIIDOC-GENERATOR, FU-VALIDATION-ENGINE, CTRL-TRACEABILITY-COVERAGE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateFromFile ¶

func GenerateFromFile(architecturePath, viewID string) (Result, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-003 ENGMODEL-LINKS: FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS, FU-CLI-ORCHESTRATION, FU-VIEW-PROJECTION

type Risk ¶ added in v0.5.0

type Risk = model.Risk

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type RiskEvidence ¶ added in v0.5.0

type RiskEvidence = model.RiskEvidence

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SQAAudit ¶ added in v0.5.0

type SQAAudit = model.SQAAudit

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Satisfaction ¶ added in v0.5.0

type Satisfaction = model.Satisfaction

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticContent ¶ added in v0.5.0

type SemanticContent = model.SemanticContent

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticDiagnostic ¶ added in v0.5.0

type SemanticDiagnostic = model.SemanticDiagnostic

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

func GenerateSysMLV2Projection ¶ added in v0.2.0

func GenerateSysMLV2Projection(semantic SemanticModel) (string, []SemanticDiagnostic)

GenerateSysMLV2Projection renders a pre-built semantic graph. Missing rendering rules are errors; official concepts are never replaced by a generic item declaration.

TRLC-LINKS: REQ-EMG-036 ENGMODEL-LINKS: FU-SYSML-EXPORTER, DO-CANONICAL-SEMANTIC-MODEL, DO-SYSML-V2-MODEL

func ValidateSemanticModel ¶ added in v0.5.0

func ValidateSemanticModel(semantic SemanticModel) []SemanticDiagnostic

ValidateSemanticModel checks identity, relationship and ownership invariants of a semantic model. ENGMODEL-LINKS: FU-MODEL-LOADER, DO-CANONICAL-SEMANTIC-MODEL TRLC-LINKS: REQ-EMG-035, REQ-EMG-036, REQ-EMG-037

type SemanticElement ¶ added in v0.5.0

type SemanticElement = model.SemanticElement

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticElementKind ¶ added in v0.5.0

type SemanticElementKind = model.SemanticElementKind

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticExpression ¶ added in v0.5.0

type SemanticExpression = model.SemanticExpression

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticFeature ¶ added in v0.5.0

type SemanticFeature = model.SemanticFeature

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticFeatureKind ¶ added in v0.5.0

type SemanticFeatureKind = model.SemanticFeatureKind

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticImport ¶ added in v0.5.0

type SemanticImport = model.SemanticImport

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticMetadata ¶ added in v0.5.0

type SemanticMetadata = model.SemanticMetadata

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticModel ¶ added in v0.5.0

type SemanticModel = model.SemanticModel

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

func ImportSysMLV2Project ¶ added in v0.2.0

func ImportSysMLV2Project(sourcePath string) (SemanticModel, error)

ImportSysMLV2Project reconstructs the canonical semantic model from legacy projects that embedded an Engineering Model payload. Native projections do not embed non-SysML canonical data.

TRLC-LINKS: REQ-EMG-036, REQ-EMG-037

type SemanticQuantity ¶ added in v0.5.0

type SemanticQuantity = model.SemanticQuantity

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticRelationship ¶ added in v0.5.0

type SemanticRelationship = model.SemanticRelationship

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticRelationshipKind ¶ added in v0.5.0

type SemanticRelationshipKind = model.SemanticRelationshipKind

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticSeverity ¶ added in v0.5.0

type SemanticSeverity = model.SemanticSeverity

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SemanticValue ¶ added in v0.5.0

type SemanticValue = model.SemanticValue

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type Severity ¶ added in v0.5.0

type Severity = validate.Severity

Severity ranks a Diagnostic.

type SpecDeltaOperation ¶ added in v0.6.0

type SpecDeltaOperation = reqdelta.SpecDeltaOperation

SpecDeltaOperation names the OpenSpec delta section RenderSpecDelta renders. ENGMODEL-LINKS: FU-MODEL-CHANGE

type SpecDeltaOptions ¶ added in v0.6.0

type SpecDeltaOptions = reqdelta.SpecDeltaOptions

SpecDeltaOptions selects the requirements to render (IDs or Prefix) and the optional capability heading and delta operation. ENGMODEL-LINKS: FU-MODEL-CHANGE, DO-REQUIREMENTS-DOCUMENT

type SpecDeltaResult ¶ added in v0.6.0

type SpecDeltaResult = reqdelta.SpecDeltaResult

SpecDeltaResult is the rendered spec delta markdown, the rendered IDs and warnings. ENGMODEL-LINKS: FU-MODEL-CHANGE, DO-REQUIREMENTS-DOCUMENT

func RenderSpecDelta ¶ added in v0.6.0

func RenderSpecDelta(requirements []Requirement, options SpecDeltaOptions) (SpecDeltaResult, error)

RenderSpecDelta renders OpenSpec spec delta markdown from model requirements: one requirement per entry whose "<ID>: <text>" line starts with the model text (shall and must capitalized) and one scenario from verificationCriteria. TRLC-LINKS: REQ-EMG-081 ENGMODEL-LINKS: FU-MODEL-CHANGE, DO-REQUIREMENTS-DOCUMENT

func RenderSpecDeltaFromModel ¶ added in v0.6.0

func RenderSpecDeltaFromModel(manifestPath string, options SpecDeltaOptions) (SpecDeltaResult, error)

RenderSpecDeltaFromModel loads engmod.yml and renders its selected requirements. TRLC-LINKS: REQ-EMG-081 ENGMODEL-LINKS: FU-MODEL-CHANGE, FU-MODEL-LOADER, DO-REQUIREMENTS-DOCUMENT

type StableIdentifierGuide ¶ added in v0.5.0

type StableIdentifierGuide = model.StableIdentifierGuide

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type State ¶ added in v0.5.0

type State = model.State

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type StructuralCoverage ¶ added in v0.5.0

type StructuralCoverage = model.StructuralCoverage

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type StructurizrExportResult ¶

type StructurizrExportResult = structurizr.Result

ENGMODEL-LINKS: FU-STRUCTURIZR-EXPORTER, DO-STRUCTURIZR-DSL, FU-VALIDATION-ENGINE, CTRL-TRACEABILITY-COVERAGE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateStructurizrDSL ¶

func GenerateStructurizrDSL(bundle Bundle) (StructurizrExportResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-005, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-STRUCTURIZR-EXPORTER, DO-STRUCTURIZR-DSL, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS, DEP-LOCAL-WORKSPACE, DEP-CI-PIPELINE, FU-VALIDATION-ENGINE, CTRL-TRACEABILITY-COVERAGE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateStructurizrDSLFromFile ¶

func GenerateStructurizrDSLFromFile(architecturePath string) (StructurizrExportResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-005 ENGMODEL-LINKS: FU-STRUCTURIZR-EXPORTER, DO-STRUCTURIZR-DSL, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

type Subsystem ¶ added in v0.5.0

type Subsystem = model.Subsystem

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type SysMLCoverageAuthority ¶ added in v0.2.0

type SysMLCoverageAuthority = sysml.CoverageAuthority

type SysMLCoverageCheckEvidence ¶ added in v0.2.0

type SysMLCoverageCheckEvidence = sysml.CoverageCheckEvidence

type SysMLCoverageManifest ¶ added in v0.2.0

type SysMLCoverageManifest = sysml.CoverageManifest

func SysMLV2Coverage ¶ added in v0.2.0

func SysMLV2Coverage() SysMLCoverageManifest

SysMLV2Coverage returns metaclass/property-level evidence generated from the pinned official inventory and strict binding.

TRLC-LINKS: REQ-EMG-039, REQ-EMG-040

type SysMLCoverageTotals ¶ added in v0.2.0

type SysMLCoverageTotals = sysml.CoverageTotals

type SysMLExportResult ¶ added in v0.2.0

type SysMLExportResult = sysml.ExportResult

SysMLExportResult is a deterministic textual projection plus explicit projection and conformance diagnostics.

func ExportSysMLV2Project ¶ added in v0.2.0

func ExportSysMLV2Project(architecturePath, projectDir, kparPath, sysandPath string) (SysMLExportResult, error)

ExportSysMLV2Project creates a Sysand interchange project and builds its KPAR. Sysand, rather than a custom ZIP writer, owns all normative KPAR packaging.

TRLC-LINKS: REQ-EMG-036, REQ-EMG-037 ENGMODEL-LINKS: FU-SYSML-EXPORTER, IF-CLI-ENGSYSML, DO-SYSML-V2-MODEL, REF-SYSML-V2-TOOLCHAIN

func GenerateSysMLV2 ¶ added in v0.2.0

func GenerateSysMLV2(bundle Bundle) (SysMLExportResult, error)

GenerateSysMLV2 validates and projects a Bundle before rendering.

TRLC-LINKS: REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-SYSML-EXPORTER, DO-CANONICAL-SEMANTIC-MODEL, DO-SYSML-V2-MODEL

func GenerateSysMLV2FromFile ¶ added in v0.2.0

func GenerateSysMLV2FromFile(architecturePath string) (SysMLExportResult, error)

GenerateSysMLV2FromFile loads the canonical YAML input and generates a SysML v2 textual projection.

TRLC-LINKS: REQ-EMG-035, REQ-EMG-036, REQ-EMG-037, REQ-EMG-047, REQ-EMG-050 ENGMODEL-LINKS: FU-SYSML-EXPORTER, IF-CLI-ENGSYSML, DO-CANONICAL-SEMANTIC-MODEL, DO-SYSML-V2-MODEL, REF-SYSML-V2-TOOLCHAIN

type SysMLExtensionCoverage ¶ added in v0.2.0

type SysMLExtensionCoverage = sysml.ExtensionCoverage

type SysMLMetaclassCoverage ¶ added in v0.2.0

type SysMLMetaclassCoverage = sysml.MetaclassCoverage

type SysMLPropertyCoverage ¶ added in v0.2.0

type SysMLPropertyCoverage = sysml.PropertyCoverage

type SysMLRelationshipCoverage ¶ added in v0.2.0

type SysMLRelationshipCoverage = sysml.RelationshipCoverage

type SysMLRendererCoverage ¶ added in v0.2.0

type SysMLRendererCoverage = sysml.RendererCoverage

type SysMLRendererEvidence ¶ added in v0.2.0

type SysMLRendererEvidence = sysml.RendererEvidence

type SysMLRoundTripResult ¶ added in v0.2.0

type SysMLRoundTripResult = sysml.RoundTripResult

SysMLRoundTripResult captures the normative KPAR path and reopened native SysML source used for source-integrity comparison.

func ReopenSysMLV2Project ¶ added in v0.2.0

func ReopenSysMLV2Project(kparPath, reopenedDir, sysandPath string) (SysMLRoundTripResult, error)

ReopenSysMLV2Project clones a KPAR with Sysand and returns its native SysML project source.

TRLC-LINKS: REQ-EMG-036, REQ-EMG-037

func VerifySysMLV2RoundTrip ¶ added in v0.2.0

func VerifySysMLV2RoundTrip(architecturePath, kparPath, reopenedDir, sysandPath string) (SysMLRoundTripResult, error)

VerifySysMLV2RoundTrip compares the reopened KPAR source to a fresh native SysML projection of the authored Engineering Model.

TRLC-LINKS: REQ-EMG-036, REQ-EMG-037

type TRLCExportOptions ¶

type TRLCExportOptions = trlc.Options

ENGMODEL-LINKS: FU-TRLC-EXPORTER, CTRL-TRACEABILITY-COVERAGE

type TRLCExportResult ¶

type TRLCExportResult = trlc.Result

ENGMODEL-LINKS: FU-TRLC-EXPORTER, CTRL-TRACEABILITY-COVERAGE

func GenerateTRLCRequirements ¶

func GenerateTRLCRequirements(requirements RequirementsDocument, options TRLCExportOptions) (TRLCExportResult, error)

TRLC-LINKS: REQ-EMG-006, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-TRLC-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

func GenerateTRLCRequirementsFromFile ¶

func GenerateTRLCRequirementsFromFile(requirementsPath string, options TRLCExportOptions) (TRLCExportResult, error)

TRLC-LINKS: REQ-EMG-006 ENGMODEL-LINKS: FU-TRLC-EXPORTER, CTRL-TRACEABILITY-COVERAGE, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

type ThreatAssumption ¶ added in v0.5.0

type ThreatAssumption = model.ThreatAssumption

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ThreatAssumptionEvidence ¶ added in v0.5.0

type ThreatAssumptionEvidence = model.ThreatAssumptionEvidence

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ThreatMitigation ¶ added in v0.5.0

type ThreatMitigation = model.ThreatMitigation

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ThreatMitigationEvidence ¶ added in v0.5.0

type ThreatMitigationEvidence = model.ThreatMitigationEvidence

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ThreatModelExportOptions ¶

type ThreatModelExportOptions = threatmodel.Options

ENGMODEL-LINKS: FU-THREAT-EXPORTER, DO-THREAT-DRAGON-JSON

type ThreatModelExportResult ¶

type ThreatModelExportResult = threatmodel.Result

ENGMODEL-LINKS: FU-THREAT-EXPORTER, DO-THREAT-DRAGON-JSON, FU-VALIDATION-ENGINE, CTRL-TRACEABILITY-COVERAGE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateThreatModelExport ¶

func GenerateThreatModelExport(bundle Bundle, options ThreatModelExportOptions) (ThreatModelExportResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-004, REQ-EMG-011, REQ-EMG-035, REQ-EMG-036 ENGMODEL-LINKS: FU-THREAT-EXPORTER, DO-THREAT-DRAGON-JSON, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS, FU-VALIDATION-ENGINE, CTRL-TRACEABILITY-COVERAGE, STATE-MODEL-INVALID, EVT-VALIDATION-FAILED

func GenerateThreatModelExportFromFile ¶

func GenerateThreatModelExportFromFile(architecturePath string, options ThreatModelExportOptions) (ThreatModelExportResult, error)

TRLC-LINKS: REQ-EMG-001, REQ-EMG-004, REQ-EMG-011 ENGMODEL-LINKS: FU-THREAT-EXPORTER, DO-THREAT-DRAGON-JSON, FLOW-MODEL-CHANGE-TO-VERIFIED-ARTIFACTS

type ThreatModelFormat ¶

type ThreatModelFormat = threatmodel.Format

ENGMODEL-LINKS: FU-THREAT-EXPORTER, DO-THREAT-DRAGON-JSON

type ThreatOutOfScope ¶ added in v0.5.0

type ThreatOutOfScope = model.ThreatOutOfScope

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ThreatOutOfScopeEvidence ¶ added in v0.5.0

type ThreatOutOfScopeEvidence = model.ThreatOutOfScopeEvidence

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ThreatScenario ¶ added in v0.5.0

type ThreatScenario = model.ThreatScenario

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ThreatScenarioEvidence ¶ added in v0.5.0

type ThreatScenarioEvidence = model.ThreatScenarioEvidence

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ToolAssessment ¶ added in v0.5.0

type ToolAssessment = model.ToolAssessment

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type TraceCodeRef ¶

type TraceCodeRef = trace.CodeRef

TraceCodeRef is a code symbol that implements a requirement. ENGMODEL-LINKS: FU-CODEMAP-INFERENCE

type TraceDelegatedStatus ¶ added in v0.4.0

type TraceDelegatedStatus = trace.DelegatedStatus

TraceDelegatedStatus is the trace status of a delegation's target requirement computed in the dependency itself. Status is "implemented", "test-linked", "delegated" or "orphan" as in that repository's own matrix, "not-available" when the dependency has no code sources, and "unknown-requirement" when the target requirement does not exist there. ENGMODEL-LINKS: FU-ALLOCATION-TRACE, FU-SYSTEM-COMPOSITION

type TraceDelegation ¶

type TraceDelegation = trace.Delegation

TraceDelegation is the downward allocation of a requirement onto a subsystem. ENGMODEL-LINKS: FU-ALLOCATION-TRACE

type TraceMatrix ¶

type TraceMatrix = trace.Matrix

TraceMatrix is the consolidated, machine-readable traceability matrix for one model. ENGMODEL-LINKS: FU-ALLOCATION-TRACE, CTRL-TRACEABILITY-COVERAGE

type TraceOptions ¶ added in v0.4.0

type TraceOptions = trace.Options

TraceOptions configures BuildTraceMatrixFromFilesWith. TRLC-LINKS: REQ-EMG-063, REQ-EMG-064, REQ-EMG-066

type TraceProvenance ¶ added in v0.2.0

type TraceProvenance = trace.Provenance

TraceProvenance identifies the selected dependency publication that supplied an imported requirement. TRLC-LINKS: REQ-EMG-050, REQ-EMG-051

type TraceRow ¶

type TraceRow = trace.Row

TraceRow is one requirement and everything that traces to it. ENGMODEL-LINKS: FU-ALLOCATION-TRACE, CTRL-TRACEABILITY-COVERAGE

type TraceSummary ¶

type TraceSummary = trace.Summary

TraceSummary is the headline coverage roll-up. ENGMODEL-LINKS: FU-ALLOCATION-TRACE

type TrustBoundary ¶ added in v0.5.0

type TrustBoundary = model.TrustBoundary

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type UncoveredDisposition ¶ added in v0.5.0

type UncoveredDisposition = model.UncoveredDisposition

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ValidationRules ¶ added in v0.5.0

type ValidationRules = validate.Rules

ValidationRules is the machine-readable subset of the validation rules (controlled vocabularies, relationship kind pairs, field rules).

func AuthoringRules ¶ added in v0.5.0

func AuthoringRules() ValidationRules

AuthoringRules returns the validation rules an author needs before editing YAML, derived from the same tables ValidateBundle uses. ENGMODEL-LINKS: FU-VALIDATION-ENGINE, DO-MODEL-AUTHORING-CONTRACT TRLC-LINKS: REQ-EMG-045, REQ-EMG-009

type VerificationExecution ¶ added in v0.5.0

type VerificationExecution = model.VerificationExecution

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type VerificationProcedure ¶ added in v0.5.0

type VerificationProcedure = model.VerificationProcedure

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type View ¶ added in v0.5.0

type View = model.View

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type ViewsDocument ¶ added in v0.5.0

type ViewsDocument = model.ViewsDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

type WorkspaceDocument ¶ added in v0.5.0

type WorkspaceDocument = model.WorkspaceDocument

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

func FindWorkspace ¶ added in v0.5.0

func FindWorkspace(start string) (WorkspaceDocument, string, error)

FindWorkspace looks for engmod.work.yml from start upwards, honouring ENGMOD_WORK, and returns the document and its path (empty when none). ENGMODEL-LINKS: FU-MODEL-LOADER, FU-SYSTEM-COMPOSITION TRLC-LINKS: REQ-EMG-048

func FindWorkspaceWith ¶ added in v0.5.0

func FindWorkspaceWith(start, mode string) (WorkspaceDocument, string, error)

FindWorkspaceWith is FindWorkspace with an explicit mode: "" (look up, honouring ENGMOD_WORK), WorkspaceOff, or a path to one workspace file. ENGMODEL-LINKS: FU-MODEL-LOADER, FU-SYSTEM-COMPOSITION TRLC-LINKS: REQ-EMG-048, REQ-EMG-063

func LoadWorkspace ¶ added in v0.5.0

func LoadWorkspace(path string) (WorkspaceDocument, error)

LoadWorkspace reads the workspace file at path. ENGMODEL-LINKS: FU-MODEL-LOADER, FU-SYSTEM-COMPOSITION TRLC-LINKS: REQ-EMG-048, REQ-EMG-049

type WorkspaceReplacement ¶ added in v0.5.0

type WorkspaceReplacement = model.WorkspaceReplacement

Model types. Each is an alias of the internal model type, so values move freely between the facade and every generator in this package. The set is every exported type reachable from Bundle, CanonicalBundle, WorkspaceDocument, ManifestDocument, AuthoringContract and SemanticModel.

Directories ¶

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

Path	Synopsis
cmd
engair command ENGMODEL-OWNER-UNIT: FU-AIRBORNE-ASSURANCE-EXPORTER	ENGMODEL-OWNER-UNIT: FU-AIRBORNE-ASSURANCE-EXPORTER
engchange command ENGMODEL-OWNER-UNIT: FU-MODEL-CHANGE	ENGMODEL-OWNER-UNIT: FU-MODEL-CHANGE
engdoc command ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION	ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION
engdragon command ENGMODEL-OWNER-UNIT: FU-THREAT-EXPORTER	ENGMODEL-OWNER-UNIT: FU-THREAT-EXPORTER
enggemara command ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION Command enggemara renders the engineering model into OpenSSF Gemara documents (L1 Vector/Principle/Guidance, L2 Capability/Threat/Control, L3 Risk/Policy, L5 Evaluation Log, L6 Enforcement Log, L7 Audit Log) using the official go-gemara SDK types, with an optional OSCAL catalog and assessment-results bridge.	ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION Command enggemara renders the engineering model into OpenSSF Gemara documents (L1 Vector/Principle/Guidance, L2 Capability/Threat/Control, L3 Risk/Policy, L5 Evaluation Log, L6 Enforcement Log, L7 Audit Log) using the official go-gemara SDK types, with an optional OSCAL catalog and assessment-results bridge.
englobster command ENGMODEL-OWNER-UNIT: FU-LOBSTER-EXPORTER	ENGMODEL-OWNER-UNIT: FU-LOBSTER-EXPORTER
engmcp command ENGMODEL-OWNER-UNIT: FU-MCP-SERVER	ENGMODEL-OWNER-UNIT: FU-MCP-SERVER
engnaf command ENGMODEL-OWNER-UNIT: FU-NAF-EXPORTER	ENGMODEL-OWNER-UNIT: FU-NAF-EXPORTER
engoscal command ENGMODEL-OWNER-UNIT: FU-OSCAL-EXPORTER	ENGMODEL-OWNER-UNIT: FU-OSCAL-EXPORTER
engspec command ENGMODEL-OWNER-UNIT: FU-MODEL-CHANGE	ENGMODEL-OWNER-UNIT: FU-MODEL-CHANGE
engstruct command ENGMODEL-OWNER-UNIT: FU-STRUCTURIZR-EXPORTER	ENGMODEL-OWNER-UNIT: FU-STRUCTURIZR-EXPORTER
engsysml command ENGMODEL-OWNER-UNIT: FU-SYSML-EXPORTER	ENGMODEL-OWNER-UNIT: FU-SYSML-EXPORTER
engtrace command ENGMODEL-OWNER-UNIT: FU-ALLOCATION-TRACE	ENGMODEL-OWNER-UNIT: FU-ALLOCATION-TRACE
engtrlc command ENGMODEL-OWNER-UNIT: FU-TRLC-EXPORTER	ENGMODEL-OWNER-UNIT: FU-TRLC-EXPORTER
engview command ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION	ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION
engws command ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION	ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION
sysmlmetamodel command ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION	ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION
examples
bedrock-pr-review-github-app-sample/src ENGMODEL-OWNER-UNIT: FU-LAMBDA-RUNTIME-OPERATIONS ENGMODEL-CODE-DESCRIPTION: wires Lambda runtime entrypoints and shared execution dependencies	ENGMODEL-OWNER-UNIT: FU-LAMBDA-RUNTIME-OPERATIONS ENGMODEL-CODE-DESCRIPTION: wires Lambda runtime entrypoints and shared execution dependencies
coffee-fleet-ota-cloud-sample/src ENGMODEL-OWNER-UNIT: FU-CLOUD-RUNTIME-OPERATIONS ENGMODEL-CODE-DESCRIPTION: wires cloud runtime handlers and integration entrypoints	ENGMODEL-OWNER-UNIT: FU-CLOUD-RUNTIME-OPERATIONS ENGMODEL-CODE-DESCRIPTION: wires cloud runtime handlers and integration entrypoints
payments-engineering-sample/src ENGMODEL-OWNER-UNIT: FU-CHECKOUT ENGMODEL-CODE-DESCRIPTION: accepts checkout requests and forwards payment authorization flow input	ENGMODEL-OWNER-UNIT: FU-CHECKOUT ENGMODEL-CODE-DESCRIPTION: accepts checkout requests and forwards payment authorization flow input
internal
asciidoc ENGMODEL-OWNER-UNIT: FU-ASCIIDOC-GENERATOR	ENGMODEL-OWNER-UNIT: FU-ASCIIDOC-GENERATOR
cliflags Package cliflags gives every engmod command the same --workspace and --lock flags.	Package cliflags gives every engmod command the same --workspace and --lock flags.
codemap ENGMODEL-OWNER-UNIT: FU-CODEMAP-INFERENCE	ENGMODEL-OWNER-UNIT: FU-CODEMAP-INFERENCE
codescan ENGMODEL-OWNER-UNIT: FU-CODEMAP-INFERENCE	ENGMODEL-OWNER-UNIT: FU-CODEMAP-INFERENCE
composition ENGMODEL-OWNER-UNIT: FU-SYSTEM-COMPOSITION	ENGMODEL-OWNER-UNIT: FU-SYSTEM-COMPOSITION
engws ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION	ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION
export/airborne ENGMODEL-OWNER-UNIT: FU-AIRBORNE-ASSURANCE-EXPORTER	ENGMODEL-OWNER-UNIT: FU-AIRBORNE-ASSURANCE-EXPORTER
export/exportutil ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION	ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION
export/gemara ENGMODEL-OWNER-UNIT: FU-GEMARA-EXPORTER	ENGMODEL-OWNER-UNIT: FU-GEMARA-EXPORTER
export/lobster ENGMODEL-OWNER-UNIT: FU-LOBSTER-EXPORTER	ENGMODEL-OWNER-UNIT: FU-LOBSTER-EXPORTER
export/naf ENGMODEL-OWNER-UNIT: FU-NAF-EXPORTER	ENGMODEL-OWNER-UNIT: FU-NAF-EXPORTER
export/oscal ENGMODEL-OWNER-UNIT: FU-OSCAL-EXPORTER	ENGMODEL-OWNER-UNIT: FU-OSCAL-EXPORTER
export/structurizr ENGMODEL-OWNER-UNIT: FU-STRUCTURIZR-EXPORTER	ENGMODEL-OWNER-UNIT: FU-STRUCTURIZR-EXPORTER
export/sysml ENGMODEL-OWNER-UNIT: FU-SYSML-EXPORTER	ENGMODEL-OWNER-UNIT: FU-SYSML-EXPORTER
export/threatmodel ENGMODEL-OWNER-UNIT: FU-THREAT-EXPORTER	ENGMODEL-OWNER-UNIT: FU-THREAT-EXPORTER
export/trlc ENGMODEL-OWNER-UNIT: FU-TRLC-EXPORTER	ENGMODEL-OWNER-UNIT: FU-TRLC-EXPORTER
generate ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION	ENGMODEL-OWNER-UNIT: FU-CLI-ORCHESTRATION
integration Package integration holds cross-package end-to-end tests only: a composed system-of-systems driven through the AsciiDoc publication, the trace and the exporters (Gemara, OSCAL, SysML, Structurizr, threat model), and the multi-repository Atlas Industries example.	Package integration holds cross-package end-to-end tests only: a composed system-of-systems driven through the AsciiDoc publication, the trace and the exporters (Gemara, OSCAL, SysML, Structurizr, threat model), and the multi-repository Atlas Industries example.
mcp ENGMODEL-OWNER-UNIT: FU-MCP-SERVER	ENGMODEL-OWNER-UNIT: FU-MCP-SERVER
model ENGMODEL-OWNER-UNIT: FU-MODEL-LOADER	ENGMODEL-OWNER-UNIT: FU-MODEL-LOADER
render/diagramstyle ENGMODEL-OWNER-UNIT: FU-VIEW-PROJECTION	ENGMODEL-OWNER-UNIT: FU-VIEW-PROJECTION
render/mermaid ENGMODEL-OWNER-UNIT: FU-VIEW-PROJECTION	ENGMODEL-OWNER-UNIT: FU-VIEW-PROJECTION
render/svg ENGMODEL-OWNER-UNIT: FU-VIEW-PROJECTION	ENGMODEL-OWNER-UNIT: FU-VIEW-PROJECTION
reqdelta ENGMODEL-OWNER-UNIT: FU-MODEL-CHANGE	ENGMODEL-OWNER-UNIT: FU-MODEL-CHANGE
reqlint ENGMODEL-OWNER-UNIT: FU-VALIDATION-ENGINE	ENGMODEL-OWNER-UNIT: FU-VALIDATION-ENGINE
sysmlmetamodel ENGMODEL-OWNER-UNIT: FU-MODEL-LOADER	ENGMODEL-OWNER-UNIT: FU-MODEL-LOADER
testutil ENGMODEL-OWNER-UNIT: FU-VALIDATION-ENGINE	ENGMODEL-OWNER-UNIT: FU-VALIDATION-ENGINE
textutil Package textutil holds small, model-independent string and collection helpers shared by the generators.	Package textutil holds small, model-independent string and collection helpers shared by the generators.
trace ENGMODEL-OWNER-UNIT: FU-ALLOCATION-TRACE	ENGMODEL-OWNER-UNIT: FU-ALLOCATION-TRACE
validate ENGMODEL-OWNER-UNIT: FU-VALIDATION-ENGINE	ENGMODEL-OWNER-UNIT: FU-VALIDATION-ENGINE
view ENGMODEL-OWNER-UNIT: FU-VIEW-PROJECTION	ENGMODEL-OWNER-UNIT: FU-VIEW-PROJECTION