Introducing a new way to review your PRs.

Read the announcement

morluto / rea

Reverse engineer anything with agents, from app behavior down to native binaries.

View on GitHub

27 documents · Updated Nov 20, 2026

docs / artifact-and-application-analysis

Artifact and application analysis

REA turns a binary, package, application bundle, or captured desktop session into evidence that an engineer can inspect and relate to application behavior. It keeps source identity, observed facts, inferred structure, runtime context, and limits together so later diagnostics and reconstruction work do not overstate what the input proves.

Use Binary diagnostics and comparison for binary layout, native diagnostics, crash data, and typed interface comparison. Use Application reconstruction for managed and mobile application graphs and cross-layer reconstruction. Use JavaScript and desktop reconstruction for JavaScript, Electron, and desktop application workflows. Use Firmware and embedded analysis for firmware regions and extraction. Use Desktop application environments for the host and isolated environments that run desktop applications.

Analysis scope

Artifact and application analysis answers two linked questions. It first establishes what content is present. It then uses that content to describe application roles, relationships, and selected runtime observations that the evidence can support.

Analysis areaSystem aimResult
Artifact identityKeep bytes, paths, containers, and slices tied to one sourceStable artifact evidence
Binary diagnosticsExplain native structure and diagnostic records without changing the source claimObserved binary facts and limits
Application reconstructionConnect package parts, modules, members, and runtime rolesApplication graph and semantic links
Desktop analysisObserve a Linux application session and turn its state into a portable environmentCapture, state view, or export bundle
Runtime reconciliationRelate static application layers to selected live observationsA combined graph with source links and coverage
Comparison and tracingDerive differences and paths from authenticated evidenceLinked analyst inference

The main boundary is between observation and inference. A provider may observe a header, a file, or a runtime record. A graph may infer that two observed parts are related. Neither result alone proves that code ran or that a possible path was used.

References: src/…/JavaScriptArtifactAnalysis.ts• L72-87 src/…/JavaScriptArtifactGraphBuilder.ts• L231-277 src/…/DesktopApplicationCapture.ts• L172-200

Artifact identity

Artifact identity gives every workflow a stable subject. A subject is the selected path and its digest, with format and architecture when those facts apply. Reports are accepted only when their subject still matches the caller's selection.

This identity lets separate workflows share evidence without silently changing its meaning. A summary can change how a path is shown, but it cannot change the bytes or parent inventory that support the summary. Partial work keeps the same subject and states what remains unknown.

The system uses four useful evidence states:

  • Observed means the selected source or provider reported the fact.
  • Inferred means the system derived a bounded relationship from observed facts.
  • Unknown means the input or coverage did not establish the fact.
  • Contradicted means declared integrity or source claims conflict with observed bytes.

References: src/…/BinaryLayoutService.ts• L31-39 src/…/BinaryLayoutService.ts• L67-113 src/…/ElfDebugLinkService.ts• L45-109 src/…/JavaScriptArtifactGraphStructure.ts• L59-97

Analysis routing

Routing chooses an analysis authority that matches the target. A local input is resolved, classified, inventoried, and tied to an integrity policy before a provider or reconstruction path uses it. Unsupported formats, unstable files, unsafe paths, and mismatched format choices are refused instead of being sent to the wrong authority.

The route also separates work that needs an executable or live host from work that only needs bytes. This keeps static package analysis, resource inspection, and evidence comparison available when a native or runtime provider is not ready.

The broad route is:

flowchart LR
    A[Selected artifact or session] --> B[Identity, inventory, and coverage]
    B --> C{Analysis authority}
    C --> D[Binary diagnostics]
    C --> E[Application reconstruction]
    C --> F[Desktop capture or state view]
    C --> G[Runtime observation]
    D --> H[Evidence]
    E --> H
    F --> H
    G --> H
    H --> I[Comparison, reconciliation, trace, or export]

Each route reports its own readiness and limits. A missing optional provider is therefore different from an unsupported target or a workflow that needs a live environment.

References: src/…/JavaScriptArtifactAnalysis.ts• L101-124 src/…/JavaScriptArtifactGraphBuilder.ts• L205-250 src/…/DesktopApplicationCapture.ts• L202-249

Binary diagnostics

Binary diagnostics turn native files and diagnostic records into bounded observations. They cover layout, entropy, crash records, ELF unwind data, DWARF compile units, ELF dependencies and separate-debug links, kernel build information, kernel modules, native initializers, platform metadata, binary hardening properties, and link-like file formats.

The common contract is simple:

  • Validate the request and its resource limits.
  • Ask the matching provider for an observation.
  • Check the returned artifact identity and internal coverage.
  • Publish the result as evidence with source locations and limitations.

DWARF inspection describes compile-unit structure and source-related attributes in ELF, Mach-O, or PE images. ELF dependency inspection describes load-time declarations such as the interpreter, needed libraries, search paths, version records, and imported symbols. ELF debug-link inspection describes separate-debug hints and can compare a caller-selected candidate by its declared CRC and build identity. Its lookup paths are reported as untrusted derived hints, not filesystem searches. These workflows report what the file declares; they do not execute it, search for files, or prove that a dependency loaded.

The diagnostics describe bytes and records. They do not by themselves establish runtime behavior, security impact, or compatibility. For example, high byte entropy does not prove encryption, an unwind range does not prove a complete call stack, a compile unit does not prove a source file was used at runtime, and a debug-link match does not prove the candidate was loaded.

Native reports keep absent, unsupported, malformed, and incomplete states distinct. They also retain bounded coverage and source ranges. A universal Mach-O report must identify the selected slice, while compressed or over-budget debug data can remain present with limited decoding rather than being presented as complete. A debug candidate that cannot be read or lacks a comparable identity remains a cannot-verify result.

References: src/…/DwarfUnitsService.ts• L32-107 src/…/ElfDependenciesService.ts• L35-103 src/…/ElfDebugLinkService.ts• L45-109 src/…/ElfDebugLinkService.ts• L296-403 src/…/dwarfUnits.ts• L234-303 src/…/elfDependencies.ts• L204-243 src/…/elfDebugLink.ts• L166-192 src/…/BinaryHardeningService.ts• L29-110 src/…/ByteEntropyService.ts• L114-135 src/…/ElfUnwindRangesService.ts• L38-109 src/…/KernelModuleService.ts• L28-95 src/…/NativeInitializersService.ts• L19-88 src/…/WindowsShortcutService.ts• L18-70

Application reconstruction

Application reconstruction combines artifact evidence into a view of how an application is arranged. It projects packages, components, modules, managed members, native boundaries, launch roles, and other relationships while preserving the exact source occurrence behind each fact.

Supported ecosystems use different evidence shapes:

EcosystemReconstructed structureMain limit
AndroidManifest, resources, DEX, JVM classes, native libraries, and signing pathsPackage structure does not prove runtime calls or signing validity
AppleApp roots, nested bundles, executables, frameworks, helpers, and launch rolesNames and paths do not prove loading or language semantics
HarmonyOSPackage manifests, Ark content, resources, native libraries, and child packagesPackaging hints do not prove runtime meaning
Managed PE/CLIAssemblies, types, members, and managed-to-native declarationsStatic metadata does not prove execution
JavaScript and ElectronModules, entrypoints, assets, bridges, IPC, and semantic relationshipsStatic links do not prove registration or reachability

Managed comparison follows the same model. It authenticates two distinct source records, compares their parsed member observations, and emits a derived result linked to both inputs. A managed reconstruction import can add analyst-selected decompiler context and method locks to an authenticated static observation. Its output remains inferred and does not replace the source evidence or prove that imported code ran.

References: src/…/ManagedReconstructionService.ts• L22-37 src/…/ManagedReconstructionService.ts• L43-63 src/…/ManagedReconstructionService.ts• L79-119 src/…/ManagedMemberComparisonService.ts• L44-92 src/…/ManagedMemberComparisonService.ts• L109-228 src/…/ManagedNativeVerificationService.platform.test.ts• L99-156 src/…/JavaScriptArtifactGraphStructure.ts• L141-227

JavaScript reconstruction

JavaScript reconstruction reads a directory or ASAR as an inert artifact. It inventories files and nested containers, parses selected source and structured data, resolves paths within the artifact, and produces an application graph plus a semantic graph. It does not execute bundle bootstrap code.

The result connects several views of one application:

  • Package metadata and launch declarations describe possible entrypoints and loader scope.
  • Module relationships describe imports, exports, workers, and unresolved external or missing targets.
  • HTML, source maps, assets, routes, endpoints, storage, and configuration add application roles.
  • Electron findings relate main, renderer, preload, bridge, IPC, utility-process, protocol, and native-addon boundaries.
  • Coverage records skipped files, parse gaps, dynamic expressions, unknown package scope, and resource ceilings as unknown rather than absence.

Analysis gives application sources priority when a shared result budget is limited. It still reports files in inventory order. This keeps first-party entrypoints and Electron boundaries useful without hiding dependency files that were not fully analyzed. If an application projection is rejected, the raw static facts remain attached to the file with a projection limitation instead of being treated as a clean omission.

JSON metadata is read as source-owned facts. Valid package metadata exposes only fields declared by that document. Invalid or unavailable metadata remains distinct, so a missing manifest does not silently inherit host values or an ancestor package type.

Path resolution is context-aware. A package entrypoint, CommonJS request, ESM module URL, HTML reference, runtime path, and URL resource have different lookup rules. Resolved paths stay inside the selected logical artifact and retain conditional or unresolved outcomes when the loader context, inventory coverage, or package metadata cannot select one target.

The reconstruction flow is:

  1. Admit the selected directory or ASAR and apply its integrity policy.
  2. Inventory containers, files, hashes, unavailable entries, and source selection.
  3. Parse source and structured metadata without executing it.
  4. Resolve references and build application and semantic relationships from retained facts.
  5. Seal the graphs and publish the result with coverage and limitations.

The analysis owns source facts before it seals the graphs. If cancellation or cleanup failure occurs after that point, it can retain a partial observation with its limits instead of presenting incomplete graphs as a clean result.

References: src/…/JavaScriptArtifactAnalysis.ts• L72-124 src/…/JavaScriptArtifactAnalysis.ts• L265-385 src/…/JavaScriptArtifactGraphBuilder.ts• L205-277 src/…/JavaScriptArtifactGraphStructure.ts• L141-364 src/…/JavaScriptArtifactPathResolution.ts• L207-240

JavaScript semantic graph

The semantic graph adds bounded relationships to the application graph. It records static candidates for data flow, calls, values, objects, events, timers, requests, child processes, configuration, boundaries, and resource use while keeping unknown relationships visible.

The builder projects each source file from file-local facts into a shared graph. It models direct literals and local object or array paths when the source supports them. It keeps property reads, writes, spreads, and destructuring as resolved or candidate relationships when aliasing, getters, custom iterators, or dynamic receivers can change the result. It offers both a per-file capacity and the remaining application capacity, so a large dependency cannot consume all retained space.

Resource limits are part of the meaning of the graph. Total and per-file node and unknown ceilings can omit nodes or unknown occurrences. Large call records can also omit literal arguments when they exceed the transfer limit. The graph then marks partial coverage, records the omission reason, and keeps referential integrity among retained nodes. It does not turn a truncated graph into a complete one.

The semantic graph remains a static model. A resolved call or Electron path is a source-based relationship, not proof that the target ran. Dynamic calls, dynamic names, unavailable files, unsupported source forms, and widened returned references remain candidates or unknowns. The graph also reports the scope of its modeled families and the precision controls that limited source analysis.

References: src/…/JavaScriptSemanticGraphBuilder.ts• L189-379 src/…/JavaScriptSemanticGraphBuilder.ts• L565-740 src/…/JavaScriptSemanticGraphBuilder.ts• L796-909 src/…/JavaScriptSemanticGraphObjectProjection.ts• L24-56 src/…/JavaScriptSemanticGraphObjectProjection.ts• L75-196 src/…/JavaScriptSemanticGraphAccumulator.ts• L20-135

Electron boundaries

Electron analysis describes the boundary between renderer code, preload code, the main process, utility processes, native add-ons, and the operating system. Static analysis records BrowserWindow setup, preload paths, context-bridge exposure, IPC, sender checks, custom protocols, native binding requests, and dynamic-code findings.

These findings guide review but use careful claims. A literal IPC channel is paired only when its owner and handler are unambiguous. Dynamic channels, competing owners, candidate loader paths, and incomplete source coverage remain unresolved. A native member requested by JavaScript is not proof that a native export exists. Candidate Electron findings are retained but do not count as proven boundary coverage.

The system also supports live observation and reconciliation:

RoutePurposeClaim
Electron page observationInspect targets exposed by a selected endpointObserved page or target facts
Active Electron scenarioResolve selected paths and replay a controlled scenarioEvidence from one replay environment
Runtime reconciliationJoin verified static layers with selected passive observationsA derived graph that preserves each runtime instance and its coverage

Active observation admits every selected path before provider work. It records the authored paths and their resolved forms, then validates provider output against the selected executable and application. Runtime reconciliation keeps equal payloads from different endpoints as separate runtime instances and carries attach-limited frame or worker coverage into the combined result. These results complement static reconstruction; they do not prove behavior outside the observed scenario.

References: src/…/JavaScriptArtifactGraphBuilder.ts• L231-250 src/…/JavaScriptArtifactGraphBuilder.ts• L374-472 src/…/JavaScriptArtifactPathResolution.ts• L490-529 src/…/ElectronActiveObservationService.ts• L143-187 src/…/JavaScriptRuntimeReconciliationService.ts• L24-67

Desktop application capture

Desktop capture observes a Linux application session and the files that form its state. It admits the application and output area before it records a baseline, launches the application, samples its windows, and records named checkpoints as files change. The output is a portable capture with retained content, host facts, application facts, process ownership, and explicit limits.

Capture scope is deliberate. State directories and selected paths become content roots. Broad arguments such as the home directory are not retained as unrestricted content roots. The capture also keeps database sidecars and records when a path could not be fully observed. Process and inspection cleanup remains owned until it is verified, even when publication fails.

The capture lifecycle is:

sequenceDiagram
    participant R as REA
    participant H as Desktop host
    participant A as Application
    R->>H: Admit host, application, and output
    R->>H: Record baseline
    R->>A: Launch application
    loop Named checkpoints
        R->>H: Record state and retained files
    end
    R->>A: Stop session
    R->>H: Publish capture evidence

The capture is an observed, controlled replay of one host session. It does not attribute each changed path to a writer, and a missed or truncated walk remains a limitation rather than proof that no change occurred. A cancellation after useful checkpoints can publish those checkpoints with an explicit cancelled end state. If capture fails before publication, the output is discarded rather than mistaken for a usable session.

References: src/…/DesktopApplicationCapture.ts• L115-200 src/…/DesktopApplicationCapture.ts• L202-249 src/…/DesktopApplicationCapture.ts• L254-353 src/…/DesktopApplicationCapture.ts• L356-431 src/…/DesktopApplicationCapture.test.ts• L516-549

Desktop state views

The desktop state view turns retained checkpoint content into readable application state. It identifies likely roles from paths, changes, open files, window facts, and dconf names. It reads supported text, JSON, key files, XML, ZIP, gzip, dconf, and SQLite content within explicit view limits.

The state view compares versions at checkpoints. It can show created, deleted, changed, format-changed, content-only, and unreadable transitions. It keeps view errors and missing retained content visible, which prevents a truncated walk, missing database sidecar, or failed dconf reader from becoming a false no-change result. Dconf command failures keep their class and command details in the state evidence.

Database views require a coherent set of retained sidecars at the same checkpoint. If the capture cannot establish that set, the database remains unreadable for that version. Archive views inspect bounded entries without extracting them or opening archives inside archives.

References: src/…/DesktopApplicationState.ts• L111-203 src/…/DesktopApplicationState.ts• L297-413 src/…/DesktopApplicationState.ts• L425-544 src/…/DesktopApplicationState.ts• L546-627 src/…/DesktopDconfDiagnostics.test.ts• L66-98

Desktop application export

Desktop export uses a chosen seed and end checkpoint to create a runnable application environment. It rewrites paths and identity-bearing data for the new home, omits lock and unsafe state, records files that were not retained, and can add validated tasks. Sensitive or withheld files stay outside the normal bundle and require explicit consent when their state is seeded.

The export joins four kinds of input:

  • The capture supplies the application launch facts, package source, host identity, owned paths, and retained bytes.
  • The state view supplies checkpoint versions and the values that task checks can read.
  • The export plan selects seed and end checkpoints, removes unsafe state, and defines the environment launch plan.
  • Task, reader, screenshot, and withheld-file checks decide what the bundle may verify or carry.

Launch planning maps observed working directories, selected documents, aliases, and URL or argument forms into the seeded home. It refuses conflicting replay locations instead of choosing a path that the capture did not prove. This keeps the exported launch context tied to the files that the bundle actually seeds.

Seed bytes are scrubbed where their format supports safe identity replacement. Binary state is copied as captured. The export reports scrubbed, recompressed, unchanged, unseeded, and still identity-bearing files rather than hiding those differences.

The output destination is admitted before writing. Unpublished output is rolled back on failure. A published bundle remains available when final cleanup or a separate withheld copy fails, with the cleanup owner retained for retry.

References: src/…/DesktopApplicationExport.ts• L203-303 src/…/DesktopApplicationExport.ts• L355-463 src/…/DesktopExportLaunch.ts• L28-51 src/…/DesktopExportLaunch.ts• L113-207 src/…/DesktopExportReaders.ts• L62-152 src/…/DesktopApplicationExport.test.ts• L298-381

Desktop task drafting

Task drafting turns a capture's net change into a starting task. It selects owned files between a seed and end checkpoint, exposes bounded values and views, and suggests checks and guards that an engineer can review before export.

The draft is not a proof of the desired task. It uses observed changes and the selected view policy. Files outside owned paths, withheld state, incomplete walks, unreadable dconf or database content, and values beyond its draft limits remain excluded or named as limitations. An apparent empty change is not treated as no change when capture coverage is incomplete.

References: src/…/DesktopTaskDraft.ts• L34-41 src/…/DesktopTaskDraft.ts• L58-181 src/…/DesktopTaskDraftNotes.test.ts• L151-239 src/…/DesktopTaskDraftNotes.test.ts• L292-400

Desktop build environments

Build environments provide a controlled place to install, capture, export, and test a desktop application. A build computer owns the application session, action log, capture, task witness, secret handling, and teardown. It can start from a request or an exported bundle and can measure a task in fresh computers.

The build workflow links capture to verification:

  1. Start a build computer with its application source and required packages.
  2. Capture the application and mark seed, end, and optional task checkpoints.
  3. Stop the capture and draft task checks from the recorded state.
  4. Export a portable bundle after validating tasks and removing or withholding secrets.
  5. Start a fresh computer from the bundle and witness task stages against the seed, change, near miss, and reset state.

The build host checks that the installed REA runtime supports the export contract before it captures work. Command results are bounded and secret values are redacted before they become host-side diagnostics. A failed start, command, reader, judge, or workspace close remains owned until teardown is verified.

Task checks can use application state, private reader views, or screenshots. The witness reports when a view was incomplete, when the application did not settle, and when reset did not restore the seed. A failed teardown remains owned so a later close can retry it. Task measurement repeats solves in fresh computers and records cost, turns, outcomes, and difficulty without replacing prior valid records when a later solve or write fails.

References: src/…/DesktopBuildComputers.ts• L237-335 src/…/DesktopBuildComputers.ts• L408-487 src/…/DesktopBuildComputers.ts• L601-705 src/…/DesktopBuildCapture.ts• L142-224 src/…/DesktopBuildCapture.ts• L271-277 src/…/DesktopBuildSolves.ts• L257-301 src/…/DesktopBuildWitness.ts• L174-177 src/…/DesktopBuildWitness.ts• L276-325

Desktop secrets and withheld state

Desktop build flows keep secret values outside action logs, task records, and exported bundles. A withheld file becomes a named setting that a later environment supplies, while the original bytes can remain in a separate protected store or consented seed.

The export refuses secret-bearing seed files, unchecked compressed files, copies of withheld bytes, and sign-in state without a matching consent record. The same boundary applies to dconf state because dconf keys cannot be withheld like ordinary files. Build output and failure text are redacted before they return to the host.

References: src/…/DesktopBuildCapture.ts• L289-317 src/…/DesktopBuildCapture.ts• L602-707 src/…/DesktopExportWithheld.ts• L114-182 src/…/DesktopExportWithheld.ts• L208-237 src/…/DesktopBuildOutputRead.test.ts• L137-192

Evidence lifecycle

Evidence is the handoff between inspection, reconstruction, comparison, runtime reconciliation, and export. A provider result is schema-checked and bound to the requested subject before publication. A derived workflow authenticates every source evidence record before it reads the source graph or typed facts.

Resource ownership is part of this lifecycle. Readers, workers, output trees, private roots, runtime sessions, and provider clients remain owned until close is confirmed. If close fails after a useful result is ready, the result stays available with a cleanup obligation instead of being reported as a clean success.

Cancellation has the same rule. Work that produced valid partial evidence keeps that observation with its limits. Work that did not reach publication reports cancellation without pretending that its result was complete.

References: src/…/DesktopRetainedContent.ts• L35-113 src/…/DesktopTaskReaderCleanup.ts• L55-133 src/…/DesktopOutputTree.ts• L162-193 src/…/JavaScriptArtifactAnalysis.ts• L223-312 src/…/JavaScriptRuntimeReconciliationService.ts• L30-67

Change checklist

When these files or sections are changed, remember to consider these:

  • Keep target classification, hashing, architecture selection, and provider support aligned so no route receives a target the resolver would reject.
  • Keep observed, inferred, unknown, and contradicted states aligned across provider reports, graphs, summaries, reconciliation, comparisons, and exports.
  • Keep binary diagnostic limits and offset locations within the selected artifact. A bounded report must not publish ranges outside its source.
  • Keep ELF debug-link section states, build-id selection, derived lookup strings, candidate identity, comparison status, and candidate limitations aligned. Lookup strings are not filesystem probes.
  • Keep JavaScript application-first analysis order, package scope, JSON metadata ownership, loader mode, and path outcomes aligned across analysis and graph projection.
  • Keep raw JavaScript findings available when an application projection is rejected. A projection failure must reduce coverage rather than erase the source observation.
  • Keep logical artifact paths confined to their container. External, rejected, unavailable, not-found, and conditional outcomes must not collapse into one status.
  • Keep semantic node, unknown, transfer-record, precision, and timeout limits visible in graph coverage. Truncation must preserve referential integrity.
  • Keep property, destructuring, alias, iterator, and dynamic-call relationships conservative. A candidate must not become a resolved source claim after a later projection change.
  • Keep Electron candidate, empty, recovered, and partial coverage distinct. Candidate findings must not inflate proven boundary counts.
  • Keep active Electron authored paths, canonical paths, provider identity, and replay evidence bound to one scenario.
  • Keep desktop admission, capture scope, state roots, retained content, process ownership, checkpoint views, database sidecars, and export seed paths aligned. A path omitted from capture cannot become a seeded file.
  • Keep desktop identity scrubbing, withheld files, consent records, dconf rules, lock-file omission, launch plans, readers, and screenshots aligned across capture and export.
  • Keep task checks, reader views, screenshots, checkpoint ends, task digests, and witness stages tied to the same task and bundle.
  • Keep runtime schema checks and guest output ceilings aligned with the build capture and export contract.
  • Keep output publication separate from cleanup state. A complete output with failed close needs a retryable cleanup owner.
  • Keep derived comparisons and traces linked to the authenticated evidence actually used.

Important failure modes

TriggerConsequenceGuard
A file changes while it is being read or hashedEvidence can describe bytes different from the selected targetRecheck the admitted file identity before publication
A provider returns a different path, target, or request windowA valid-looking report can describe the wrong inputValidate the returned subject against the caller request
A debug-link candidate is unreadable, over budget, or has no comparable identityA partial or unavailable check can be mistaken for a matching debug filePreserve candidate limitations and distinguish match, mismatch, and cannot-verify
Inventory, source selection, or semantic limits leave gapsMissing relationships can be mistaken for absent relationshipsPublish explicit partial coverage and unknown scopes
A nearer JavaScript package manifest is unavailable or a loader mode is unknownA source can be assigned the wrong module type or targetKeep package scope and conditional resolution unknown until the owning metadata is established
A path crosses an ASAR boundary, artifact root, or runtime mapping that is not provenA module or runtime resource can be linked to the wrong fileKeep the path unresolved and retain its candidate and limitation
A rejected application projection is treated as a missing fileRetained static findings and Electron coverage can disappear from the resultKeep the source observation and publish the projection failure as partial coverage
A semantic graph reaches its node, unknown, or transfer-record budgetStatic relationships or direct argument values can disappear without warningMark graph coverage partial and retain unknown omissions
Electron IPC has dynamic channels, candidate loaders, or competing ownersA transmission can be paired with the wrong handler or counted as provenPair only one exact literal owner with complete coverage
Runtime observations share payload bytes but come from different endpointsSeparate live targets can be merged into one false runtime instanceInclude the selected endpoint and evidence identity in runtime-node identity
A desktop capture misses a checkpoint, window sample, database sidecar, or content rootThe state view or exported environment can omit state or report incomplete changeRetain the limitation and do not treat the gap as no change
A bundle includes a lock file, recovery state, or host identityThe application may fail to start or leak the capture hostOmit unsafe state and scrub supported identity-bearing content before export
A launch argument or working path maps to conflicting seeded locationsThe exported application can open the wrong document or use unproved stateRefuse export until one replay location is established
A task check reads outside owned or retained pathsThe task can pass or fail for data the bundle does not controlRefuse the task and require a new capture or valid reader
A seed contains a withheld secret, a copy of withheld bytes, or sign-in dconf state without consentSensitive state can enter the portable bundleRefuse export or require an explicit matching consent record
A build runtime does not advertise required export options or guest output exceeds its ceilingCapture or export can fail after the build has startedCheck the runtime schema first and refuse oversized output before fetching it
A task, verifier, or witness record differs from the selected bundleA measurement or witness can describe another taskCompare the task digest and bundle-owned task files before grading
Cancellation or cleanup fails after publicationUseful output can be lost or an open resource can be hiddenRetain partial evidence and keep cleanup retryable

Key files

FileWhy to read it
src/…/JavaScriptArtifactAnalysis.tsShows how source order, package metadata, interruptions, and coverage become analysis facts.
src/…/JavaScriptArtifactGraphBuilder.tsShows how application structure, Electron coverage, and graph limitations are assembled.
src/…/JavaScriptArtifactGraphStructure.tsShows how artifact files, packages, unavailable scopes, and roles become graph structure.
src/…/JavaScriptArtifactGraphFindings.tsShows how static references, endpoints, storage, workers, roles, and path outcomes become relationships.
src/…/JavaScriptSemanticGraphBuilder.tsShows the file-local projection, shared capacity, transfer checks, and coverage model for static semantic relationships.
src/…/JavaScriptSemanticGraphObjectProjection.tsShows the conservative model for object properties, writes, spreads, and destructuring.
src/…/JavaScriptArtifactGraphAccumulator.tsShows canonical node ownership, observation merging, and loader-qualified evidence.
src/…/JavaScriptRuntimeReconciliationService.tsShows how static and passive runtime evidence form a linked result.
src/…/ElectronActiveObservationService.tsShows the boundary for a controlled live Electron scenario.
src/…/DwarfUnitsService.tsShows how bounded compile-unit observations become identity-bound evidence.
src/…/ElfDependenciesService.tsShows how ELF load-time dependency facts are checked and published.
src/…/ElfDebugLinkService.tsShows how separate-debug linkage and candidate comparison preserve partial results.
src/…/elfDebugLink.tsDefines debug-link states, lookup strings, candidate identity, and verification limits.
src/…/BinaryLayoutService.tsShows the common binary provider validation and evidence boundary.
src/…/ManagedReconstructionService.tsShows how an authenticated managed observation becomes an inferred reconstruction result.
src/…/ManagedMemberComparisonService.tsShows authenticated comparison of two managed artifacts.
src/…/DesktopApplicationCapture.tsShows desktop admission, session capture, checkpoint recording, publication, process ownership, and observation limits.
src/…/DesktopApplicationState.tsShows how retained files, sidecars, dconf, and checkpoints become state views.
src/…/DesktopApplicationExport.tsShows how a capture becomes a portable application environment and validates tasks.
src/…/DesktopExportLaunch.tsShows how captured launch paths and documents map into the seeded home.
src/…/DesktopExportReaders.tsShows how task readers, seed views, checkpoint files, and screenshots support export checks.
src/…/DesktopExportWithheld.tsShows the boundary between portable seed state, withheld files, and consent.
src/…/DesktopBuildComputers.tsShows ownership of build computers, actions, witnesses, secrets, and teardown.
src/…/DesktopBuildCapture.tsShows build-computer capture, runtime contract checks, checkpoints, task drafts, and export admission.
src/…/DesktopBuildCommands.tsShows bounded guest output and failure projection from build computers.
src/…/DesktopBuildSolves.tsShows fresh-computer task measurement and durable difficulty records.
src/…/DesktopBuildWitness.tsShows task grading, reset checks, witness stages, and record publication.
src/…/DesktopBuildWitnessBundle.tsShows bundle task identity checks and screen-judge inputs.
src/…/DesktopOutputTree.tsShows safe output admission, commit, rollback, and cleanup reporting.