partsieve

    OOXML capability audit and verified rebuild; restricted Word and spreadsheet profiles

    ooxml
    xlsx
    docx
    vba
    audit
    verified-rebuild
    Download zip
    Author
    Version
    0.9.2
    License
    Apache-2.0
    Last updated
    6 hours ago
    Downloads
    144

    #zlhahaha/partsieve

    PartSieve audits and rebuilds supported DOCX, DOCM, XLSX and XLSM documents. See the README for installation, the 0.9.2 support profile, SDK authorization and reproducible verification.

    SieveError

    pub(all) suberror SieveError {
    Refused(String)
    Incomplete(String)
    Invalid(String)
    } derive(
    Debug
    )

    Assessment

    pub(all) struct Assessment {
    schema : String
    input_hash : String?
    findings : Array[CapabilityFinding]
    coverage : Coverage
    decision : Decision
    graph : PackageGraph?
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Assessment::equal

    fn Assessment::equal(Assessment, Assessment) -> Bool

    Assessment::not_equal

    fn Assessment::not_equal(x : Assessment, y : Assessment) -> Bool

    Assessment::to_json

    Audit

    pub(all) struct Audit {
    schema : String
    input_hash : String
    format : String
    main_part : String
    coverage : String
    profile : String
    checked_rules : Array[String]
    limitations : Array[String]
    parts : Array[PartRecord]
    relationships : Array[Relationship]
    findings : Array[Finding]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Audit::equal

    fn Audit::equal(Audit, Audit) -> Bool

    Audit::not_equal

    fn Audit::not_equal(x : Audit, y : Audit) -> Bool

    Audit::to_json

    Audit::to_repr

    AuthorizationRecord

    pub(all) struct AuthorizationRecord {
    schema : String
    input_hash : String
    plan_hash : String
    output_hash : String
    permissions : RemovalPermissions
    summary : ChangeSummary
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    AuthorizationRecord::equal

    AuthorizationRecord::not_equal

    AuthorizedRebuilt

    pub(all) struct AuthorizedRebuilt {
    bytes : Bytes
    receipt : VerifiedReceipt
    authorization : AuthorizationRecord
    }

    Capability

    pub(all) enum Capability {
    Vba
    HttpHyperlink
    RemoteTemplate
    ExternalResource
    ExternalData
    Ole
    ActiveX
    UnknownExternalRelationship
    UnknownPotentiallyActiveExtension
    } derive(Eq,
    Debug
    )

    Capability::equal

    fn Capability::equal(Capability, Capability) -> Bool

    Capability::not_equal

    fn Capability::not_equal(x : Capability, y : Capability) -> Bool

    Capability::to_json

    CapabilityFinding

    pub(all) struct CapabilityFinding {
    rule_id : String
    capability : Capability
    source : String
    part : String
    certainty : Certainty
    rebuild_support : RebuildSupport
    evidence : Array[String]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    CapabilityFinding::equal

    CapabilityFinding::not_equal

    fn CapabilityFinding::not_equal(x : CapabilityFinding, y : CapabilityFinding) -> Bool

    Certainty

    pub(all) enum Certainty {
    Declared
    Uncertain
    } derive(Eq,
    Debug
    )

    Certainty::equal

    fn Certainty::equal(Certainty, Certainty) -> Bool

    Certainty::not_equal

    fn Certainty::not_equal(x : Certainty, y : Certainty) -> Bool

    Certainty::to_json

    ChangeKind

    pub(all) enum ChangeKind {
    VbaRemoval
    OleRemoval
    TemplateRemoval
    MacroFormatConversion
    } derive(Eq,
    Debug
    )

    ChangeKind::equal

    fn ChangeKind::equal(ChangeKind, ChangeKind) -> Bool

    ChangeKind::label

    fn ChangeKind::label(self : ChangeKind) -> String

    ChangeKind::not_equal

    fn ChangeKind::not_equal(x : ChangeKind, y : ChangeKind) -> Bool

    ChangeKind::to_json

    ChangeSummary

    pub(all) struct ChangeSummary {
    changes : Array[ContentChange]
    removed_parts : Array[String]
    rewritten_parts : Array[String]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    ChangeSummary::equal

    ChangeSummary::not_equal

    fn ChangeSummary::not_equal(x : ChangeSummary, y : ChangeSummary) -> Bool

    CheckState

    pub(all) enum CheckState {
    Checked
    NotChecked
    IncompleteCheck
    Opaque
    } derive(Eq,
    Debug
    )

    CheckState::equal

    fn CheckState::equal(CheckState, CheckState) -> Bool

    CheckState::not_equal

    fn CheckState::not_equal(x : CheckState, y : CheckState) -> Bool

    CheckState::to_json

    CheckedOperation

    pub(all) struct CheckedOperation {
    operation_id : String
    kind : PlanOperationKind
    part : String
    source : String
    relationship_id : String
    rule_id : String
    decision_id : String
    before_hash : String
    expected_after_hash : String?
    depends_on : Array[String]
    reason : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    CheckedOperation::equal

    CheckedOperation::not_equal

    fn CheckedOperation::not_equal(x : CheckedOperation, y : CheckedOperation) -> Bool

    ContentChange

    pub(all) struct ContentChange {
    kind : ChangeKind
    count : Int
    removed_parts : Array[String]
    effect : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    ContentChange::equal

    ContentChange::not_equal

    fn ContentChange::not_equal(x : ContentChange, y : ContentChange) -> Bool

    ContentTypeIndex

    pub(all) struct ContentTypeIndex {
    content_type : String
    parts : Array[String]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    ContentTypeIndex::equal

    ContentTypeIndex::not_equal

    fn ContentTypeIndex::not_equal(x : ContentTypeIndex, y : ContentTypeIndex) -> Bool

    ContractDisposition

    pub(all) struct ContractDisposition {
    part : String
    classification : PreservationKind
    before_hash : String
    after_hash : String?
    decision_id : String?
    rule_id : String?
    reason : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    ContractDisposition::equal

    ContractDisposition::not_equal

    Coverage

    pub(all) struct Coverage {
    declared_profile : String
    rules : Array[RuleCoverage]
    checked_rules : Array[String]
    unchecked_features : Array[String]
    parse_complete : Bool
    parse_error : String?
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Coverage::equal

    fn Coverage::equal(Coverage, Coverage) -> Bool

    Coverage::not_equal

    fn Coverage::not_equal(x : Coverage, y : Coverage) -> Bool

    Coverage::to_json

    Coverage::to_repr

    Decision

    pub(all) struct Decision {
    result : ResultStatus
    rebuild_allowed : Bool
    profile : String
    reason : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Decision::equal

    fn Decision::equal(Decision, Decision) -> Bool

    Decision::not_equal

    fn Decision::not_equal(x : Decision, y : Decision) -> Bool

    Decision::to_json

    Decision::to_repr

    Disposition

    pub(all) struct Disposition {
    part : String
    classification : String
    before_hash : String
    after_hash : String?
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Disposition::equal

    fn Disposition::equal(Disposition, Disposition) -> Bool

    Disposition::not_equal

    fn Disposition::not_equal(x : Disposition, y : Disposition) -> Bool

    DocumentAuthorization

    pub struct DocumentAuthorization {
    // private fields
    }

    Trusted application decision, not a signed credential or client JSON token.

    DocumentPreview

    pub struct DocumentPreview {
    // private fields
    }

    Opaque in-memory review. Getters never expose its mutable plan/summary arrays.

    DocumentPreview::input_hash

    fn DocumentPreview::input_hash(self : DocumentPreview) -> String

    DocumentPreview::plan_hash

    fn DocumentPreview::plan_hash(self : DocumentPreview) -> String

    DocumentPreview::plan_json

    Detached plan data for display/storage. This JSON is not authorization.

    DocumentPreview::summary

    DocumentPreview::to_json

    FailureCode

    pub(all) enum FailureCode {
    InvalidConfiguration
    UnsupportedDocument
    ProcessingIncomplete
    IntegrityFailure
    InputLimitExceeded
    OutputLimitExceeded
    Cancelled
    WorkBudgetExceeded
    InternalFailure
    AuthorizationDenied
    } derive(Eq,
    Debug
    )

    Stable business categories. Do not branch on SdkFailure.message. ProcessingIncomplete includes parser/structural limits without a finer code.

    FailureCode::equal

    fn FailureCode::equal(FailureCode, FailureCode) -> Bool

    FailureCode::label

    fn FailureCode::label(self : FailureCode) -> String

    FailureCode::not_equal

    fn FailureCode::not_equal(x : FailureCode, y : FailureCode) -> Bool

    FailureCode::to_json

    Finding

    pub(all) struct Finding {
    rule : String
    capability : String
    part : String
    evidence : Array[String]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Finding::equal

    fn Finding::equal(Finding, Finding) -> Bool

    Finding::not_equal

    fn Finding::not_equal(x : Finding, y : Finding) -> Bool

    Finding::to_json

    Finding::to_repr

    GraphNode

    pub(all) struct GraphNode {
    part : String
    inbound : Array[Int]
    outbound : Array[Int]
    xml_references : Array[Int]
    reachable : Bool
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    GraphNode::equal

    fn GraphNode::equal(GraphNode, GraphNode) -> Bool

    GraphNode::not_equal

    fn GraphNode::not_equal(x : GraphNode, y : GraphNode) -> Bool

    GraphNode::to_json

    ImplicitReference

    pub(all) struct ImplicitReference {
    source : String
    relationship_index : Int
    semantics : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    ImplicitReference::equal

    ImplicitReference::not_equal

    fn ImplicitReference::not_equal(x : ImplicitReference, y : ImplicitReference) -> Bool

    Limits

    pub(all) struct Limits {
    input_bytes : Int
    entry_bytes : Int
    total_bytes : Int
    entries : Int
    xml_bytes : Int
    xml_depth : Int
    xml_nodes : Int
    xml_attributes : Int
    output_bytes : Int
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Limits::default

    fn Limits::default() -> Limits

    Limits::equal

    fn Limits::equal(Limits, Limits) -> Bool

    Limits::not_equal

    fn Limits::not_equal(x : Limits, y : Limits) -> Bool

    Limits::to_json

    Limits::to_repr

    Operation

    pub(all) struct Operation {
    kind : String
    part : String
    relationship_id : String
    rule : String
    reason : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Operation::equal

    fn Operation::equal(Operation, Operation) -> Bool

    Operation::not_equal

    fn Operation::not_equal(x : Operation, y : Operation) -> Bool

    Operation::to_json

    PackageGraph

    pub(all) struct PackageGraph {
    schema : String
    root : String
    parts : Array[PartRecord]
    relationships : Array[Relationship]
    xml_references : Array[XmlReference]
    implicit_references : Array[ImplicitReference]
    nodes : Array[GraphNode]
    content_types : Array[ContentTypeIndex]
    reachable : Array[String]
    orphan_candidates : Array[String]
    coverage_gaps : Array[String]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    PackageGraph::equal

    PackageGraph::not_equal

    fn PackageGraph::not_equal(x : PackageGraph, y : PackageGraph) -> Bool

    PartRecord

    pub(all) struct PartRecord {
    name : String
    content_type : String
    sha256 : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    PartRecord::equal

    fn PartRecord::equal(PartRecord, PartRecord) -> Bool

    PartRecord::not_equal

    fn PartRecord::not_equal(x : PartRecord, y : PartRecord) -> Bool

    PartRecord::to_json

    PlanOperationKind

    pub(all) enum PlanOperationKind {
    RemovePart
    RemoveRelationship
    RewriteSourceXml
    RewriteRelationshipPart
    RewriteContentTypes
    ChangeMainContentType
    } derive(Eq,
    Debug
    )

    PlanOperationKind::equal

    PlanOperationKind::not_equal

    fn PlanOperationKind::not_equal(x : PlanOperationKind, y : PlanOperationKind) -> Bool

    PlanOperationKind::to_json

    PolicyAction

    pub(all) enum PolicyAction {
    AllowAction
    RemoveAction
    RefuseAction
    } derive(Eq,
    Debug
    )

    PolicyAction::equal

    PolicyAction::not_equal

    fn PolicyAction::not_equal(x : PolicyAction, y : PolicyAction) -> Bool

    PolicyAction::to_json

    PolicyDecision

    pub(all) struct PolicyDecision {
    decision_id : String
    finding_index : Int?
    action : PolicyAction
    rule_id : String
    part : String
    reason : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    PolicyDecision::equal

    PolicyDecision::not_equal

    fn PolicyDecision::not_equal(x : PolicyDecision, y : PolicyDecision) -> Bool

    PreparedPlan

    pub(all) struct PreparedPlan {
    schema : String
    tool : String
    rules : String
    input_hash : String
    input_format : String
    output_format : String
    policy : String
    profile : String
    limits : Limits
    preconditions : Array[PartRecord]
    findings : Array[CapabilityFinding]
    decisions : Array[PolicyDecision]
    operations : Array[CheckedOperation]
    controlled_removals : Array[String]
    orphan_candidates : Array[String]
    coverage : Coverage
    gate : Decision
    unavailable_handlers : Array[String]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    PreparedPlan::equal

    PreparedPlan::not_equal

    fn PreparedPlan::not_equal(x : PreparedPlan, y : PreparedPlan) -> Bool

    Presence

    pub(all) enum Presence {
    Present
    Absent
    Unknown
    } derive(Eq,
    Debug
    )

    Presence::equal

    fn Presence::equal(Presence, Presence) -> Bool

    Presence::not_equal

    fn Presence::not_equal(x : Presence, y : Presence) -> Bool

    Presence::to_json

    Presence::to_repr

    PreservationKind

    pub(all) enum PreservationKind {
    BytePreservedKind
    SemanticallyRewrittenKind
    RemovedByPolicyKind
    RegeneratedMetadataKind
    } derive(Eq,
    Debug
    )

    PreservationKind::equal

    PreservationKind::not_equal

    fn PreservationKind::not_equal(x : PreservationKind, y : PreservationKind) -> Bool

    PreservationKind::to_json

    RebuildSupport

    pub(all) enum RebuildSupport {
    Supported
    NotSupported
    } derive(Eq,
    Debug
    )

    RebuildSupport::equal

    RebuildSupport::not_equal

    fn RebuildSupport::not_equal(x : RebuildSupport, y : RebuildSupport) -> Bool

    RebuildSupport::to_json

    Rebuilt

    pub(all) struct Rebuilt {
    bytes : Bytes
    receipt : Receipt
    }

    Receipt

    pub(all) struct Receipt {
    schema : String
    tool : String
    rules : String
    policy : String
    profile : String
    input_hash : String
    output_hash : String
    input_size : Int
    output_size : Int
    input_format : String
    output_format : String
    limits : Limits
    audit : Audit
    plan : RewritePlan
    dispositions : Array[Disposition]
    structure : String
    preservation : String
    independent_validation : String
    limitations : Array[String]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Receipt::equal

    fn Receipt::equal(Receipt, Receipt) -> Bool

    Receipt::not_equal

    fn Receipt::not_equal(x : Receipt, y : Receipt) -> Bool

    Receipt::to_json

    Receipt::to_repr

    Relationship

    pub(all) struct Relationship {
    source : String
    id : String
    kind : String
    target : String
    resolved : String
    external : Bool
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Relationship::equal

    Relationship::not_equal

    fn Relationship::not_equal(x : Relationship, y : Relationship) -> Bool

    RemovalPermissions

    pub(all) struct RemovalPermissions {
    remove_vba : Bool
    remove_ole : Bool
    remove_remote_template : Bool
    convert_macro_format : Bool
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    These flags cover only the exact reviewed plan, never arbitrary future inputs.

    RemovalPermissions::all_supported

    fn RemovalPermissions::all_supported() -> RemovalPermissions

    RemovalPermissions::allows

    fn RemovalPermissions::allows(self : RemovalPermissions, kind : ChangeKind) -> Bool

    RemovalPermissions::deny_all

    RemovalPermissions::equal

    RemovalPermissions::macros_only

    RemovalPermissions::not_equal

    ResultStatus

    pub(all) enum ResultStatus {
    Pass
    Fail
    IncompleteResult
    Unsupported
    } derive(Eq,
    Debug
    )

    ResultStatus::equal

    ResultStatus::not_equal

    fn ResultStatus::not_equal(x : ResultStatus, y : ResultStatus) -> Bool

    ResultStatus::to_json

    RewritePlan

    pub(all) struct RewritePlan {
    schema : String
    input_hash : String
    policy : String
    profile : String
    operations : Array[Operation]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    RewritePlan::equal

    fn RewritePlan::equal(RewritePlan, RewritePlan) -> Bool

    RewritePlan::not_equal

    fn RewritePlan::not_equal(x : RewritePlan, y : RewritePlan) -> Bool

    RuleCoverage

    pub(all) struct RuleCoverage {
    rule_id : String
    capability : Capability
    state : CheckState
    presence : Presence
    rebuild_support : RebuildSupport
    reason : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    RuleCoverage::equal

    RuleCoverage::not_equal

    fn RuleCoverage::not_equal(x : RuleCoverage, y : RuleCoverage) -> Bool

    SdkFailure

    pub(all) struct SdkFailure {
    code : FailureCode
    operation : SdkOperation
    message : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    Only an Err contains this diagnostic; never a partial document or receipt. Message is explanatory and may change independently of the stable code.

    SdkFailure::equal

    fn SdkFailure::equal(SdkFailure, SdkFailure) -> Bool

    SdkFailure::not_equal

    fn SdkFailure::not_equal(x : SdkFailure, y : SdkFailure) -> Bool

    SdkFailure::to_json

    SdkOperation

    pub(all) enum SdkOperation {
    CleanDocument
    PrepareDocument
    ExecuteDocumentPlan
    VerifyDocument
    PreviewDocument
    AuthorizeDocument
    ExecuteAuthorizedDocument
    } derive(Eq,
    Debug
    )

    SdkOperation::equal

    SdkOperation::not_equal

    fn SdkOperation::not_equal(x : SdkOperation, y : SdkOperation) -> Bool

    SdkOperation::to_json

    VerificationCheck

    pub(all) struct VerificationCheck {
    check_id : String
    state : CheckState
    result : ResultStatus?
    detail : String
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    VerificationCheck::equal

    VerificationCheck::not_equal

    fn VerificationCheck::not_equal(x : VerificationCheck, y : VerificationCheck) -> Bool

    VerifiedRebuilt

    pub(all) struct VerifiedRebuilt {
    bytes : Bytes
    receipt : VerifiedReceipt
    }

    VerifiedReceipt

    pub(all) struct VerifiedReceipt {
    schema : String
    tool : String
    rules : String
    policy : String
    profile : String
    input_hash : String
    output_hash : String
    input_size : Int
    output_size : Int
    input_format : String
    output_format : String
    limits : Limits
    input_coverage : Coverage
    output_coverage : Coverage
    findings : Array[CapabilityFinding]
    output_findings : Array[CapabilityFinding]
    decisions : Array[PolicyDecision]
    allowed_capabilities : Array[CapabilityFinding]
    plan : PreparedPlan
    dispositions : Array[ContractDisposition]
    checks : Array[VerificationCheck]
    result : ResultStatus
    independent_validation : CheckState
    independent_tools : Array[String]
    limitations : Array[String]
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    VerifiedReceipt::equal

    VerifiedReceipt::not_equal

    fn VerifiedReceipt::not_equal(x : VerifiedReceipt, y : VerifiedReceipt) -> Bool

    WorkControl

    pub struct WorkControl {
    allowance : Int
    should_cancel : (String) -> Bool
    consumed : Int
    stopped : String?
    stopped_kind : WorkStopKind?
    }

    A shared, sticky work allowance for one SDK call or a caller-owned workflow. Units are deterministic accounting credits, not milliseconds or heap bytes. The cancellation callback must be quick and must not reenter this control.

    WorkControl::cancel

    fn WorkControl::cancel(self : WorkControl) -> Unit

    WorkControl::default

    fn WorkControl::default() -> WorkControl

    WorkControl::new

    fn WorkControl::new(work_units? : Int, should_cancel? : (String) -> Bool) -> WorkControl raise

    The same control may be shared by prepare/rebuild/verify to bound their sum. A cancelled or exhausted control cannot be reset; create a new one to retry.

    WorkControl::remaining

    fn WorkControl::remaining(self : WorkControl) -> Int

    WorkControl::stop_kind

    fn WorkControl::stop_kind(self : WorkControl) -> WorkStopKind?

    WorkControl::stop_reason

    fn WorkControl::stop_reason(self : WorkControl) -> String?

    WorkControl::used

    fn WorkControl::used(self : WorkControl) -> Int

    WorkStopKind

    pub(all) enum WorkStopKind {
    CancelRequested
    AllowanceExhausted
    } derive(Eq,
    Debug
    )

    Machine-readable, sticky cause; the human-readable stop_reason is unchanged.

    WorkStopKind::equal

    WorkStopKind::not_equal

    fn WorkStopKind::not_equal(x : WorkStopKind, y : WorkStopKind) -> Bool

    XmlReference

    pub(all) struct XmlReference {
    source : String
    element_index : Int
    depth : Int
    element_namespace : String
    element_name : String
    attribute_name : String
    relationship_id : String
    relationship_index : Int
    } derive(Eq,
    Debug
    ,
    ToJson
    )

    XmlReference::equal

    XmlReference::not_equal

    fn XmlReference::not_equal(x : XmlReference, y : XmlReference) -> Bool

    assess

    fn assess(input : Bytes, limits? : Limits, control? : WorkControl) -> Assessment

    audit

    fn audit(input : Bytes, limits? : Limits, control? : WorkControl) -> Audit raise

    authorize_document

    fn authorize_document(preview : DocumentPreview, permissions : RemovalPermissions) -> Result[DocumentAuthorization, SdkFailure]

    Called by the trusted application after its own decision/confirmation.

    clean_document

    fn clean_document(input : Bytes, limits? : Limits, control? : WorkControl) -> Result[VerifiedRebuilt, SdkFailure]

    Default intake path: rebuild once and independently verify the actual bytes. This includes the legacy implementation's verification, not an extra pass.

    digest

    fn digest(bytes : BytesView) -> String

    execute_authorized_document

    fn execute_authorized_document(input : Bytes, authorization : DocumentAuthorization, control? : WorkControl) -> Result[AuthorizedRebuilt, SdkFailure]

    Recompute the actual plan and losses, enforce permissions, then execute/verify.

    execute_document_plan

    fn execute_document_plan(input : Bytes, plan :
    Json
    , limits? : Limits, control? : WorkControl) -> Result[VerifiedRebuilt, SdkFailure]

    Recomputes source bindings/plan constraints and verifies the actual result.

    inspect_graph

    fn inspect_graph(input : Bytes, limits? : Limits, control? : WorkControl) -> PackageGraph raise

    plan

    fn plan(input : Bytes, limits? : Limits, control? : WorkControl) -> RewritePlan raise

    prepare

    fn prepare(input : Bytes, limits? : Limits, control? : WorkControl) -> PreparedPlan raise

    prepare_document

    fn prepare_document(input : Bytes, limits? : Limits, control? : WorkControl) -> Result[PreparedPlan, SdkFailure]

    Inspect/prepare without producing output; useful before caller confirmation.

    preview_document

    fn preview_document(input : Bytes, limits? : Limits, control? : WorkControl) -> Result[DocumentPreview, SdkFailure]

    rebuild

    fn rebuild(input : Bytes, limits? : Limits, control? : WorkControl) -> Rebuilt raise

    rebuild_verified

    fn rebuild_verified(input : Bytes, limits? : Limits, control? : WorkControl) -> VerifiedRebuilt raise

    rebuild_verified_with_plan

    fn rebuild_verified_with_plan(input : Bytes, supplied :
    Json
    , limits? : Limits, control? : WorkControl) -> VerifiedRebuilt raise

    rebuild_with_plan

    fn rebuild_with_plan(input : Bytes, supplied :
    Json
    , limits? : Limits, control? : WorkControl) -> Rebuilt raise

    resolve_target

    fn resolve_target(source : String, target : String) -> String raise

    verify

    fn verify(output : Bytes, original : Bytes, limits? : Limits, control? : WorkControl) -> Receipt raise

    verify_contract

    fn verify_contract(output : Bytes, original : Bytes, limits? : Limits, control? : WorkControl) -> VerifiedReceipt raise

    verify_document

    fn verify_document(output : Bytes, original : Bytes, limits? : Limits, control? : WorkControl) -> Result[VerifiedReceipt, SdkFailure]

    Archive path: reads actual output plus original; a supplied receipt is not proof.